with embedded type and itemType attribute not reported");
}
public void testUnionReference() throws Exception {
runNoErrors(UNION_REFERENCE_SCHEMA);
}
public void testUnionInline() throws Exception {
runNoErrors(UNION_INLINE_SCHEMA);
}
public void testUnionMixed() throws Exception {
runNoErrors(UNION_MIXED_SCHEMA);
}
} libjibx1.2-java-1.2.3/build/test/org/jibx/schema/SchemaTestBase.java 0000644 0001750 0001750 00000036745 11257647464 025034 0 ustar twerner twerner /*
Copyright (c) 2007-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.io.StringReader;
import java.io.StringWriter;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Map;
import junit.framework.TestCase;
import org.jibx.binding.Loader;
import org.jibx.binding.Utility;
import org.jibx.binding.classes.BoundClass;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.MungedClass;
import org.jibx.binding.def.BindingDefinition;
import org.jibx.extras.DocumentComparator;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IUnmarshallable;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.codegen.custom.SchemasetCustom;
import org.jibx.schema.elements.SchemaElement;
import org.jibx.schema.validation.NameMergeVisitor;
import org.jibx.schema.validation.PrevalidationVisitor;
import org.jibx.schema.validation.NameRegistrationVisitor;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.schema.validation.ValidationProblem;
import org.jibx.schema.validation.ValidationVisitor;
/**
* Base class for all schema tests. This binds and loads the schema classes during initialization, and provides access
* methods for working with the schema classes.
*/
public class SchemaTestBase extends TestCase
{
private static final String SCHEMA_CLASS = "org.jibx.schema.elements.SchemaElement";
private static final String BINDING_FILE = "schema-xsprefix-binding.xml";
private static final String BINDING_NAME = "schema_xsprefix_binding";
private static final String EXTRACT_FILE = "schema-extract-binding.xml";
private static final String EXTRACT_NAME = "schema_extract_binding";
private static final IBindingFactory m_bindingFactory;
static {
ClassLoader loader;
try {
// set paths to be used for loading referenced classes
loader = SchemaTestBase.class.getClassLoader();
URL[] urls = Loader.getClassPaths();
String[] paths = new String[urls.length];
for (int i = 0; i < urls.length; i++) {
paths[i] = urls[i].getFile();
}
ClassCache.setPaths(paths);
ClassFile.setPaths(paths);
} catch (MalformedURLException e) {
throw new RuntimeException("Internal error - unable to set classpaths");
}
IBindingFactory factory = null;
try {
// look up the mapped class and existing binding factory
Class mclas = Class.forName(SCHEMA_CLASS);
factory = BindingDirectory.getFactory(BINDING_NAME, mclas);
} catch (Exception e) { /* just fall through */ }
if (factory == null) {
try {
// set paths to be used for loading referenced classes
URL[] urls = Loader.getClassPaths();
String[] paths = new String[urls.length];
for (int i = 0; i < urls.length; i++) {
paths[i] = urls[i].getFile();
}
ClassCache.setPaths(paths);
ClassFile.setPaths(paths);
// find the binding definitions
InputStream is1 = loader.getResourceAsStream(BINDING_FILE);
if (is1 == null) {
throw new RuntimeException("Schema binding definition not found");
}
InputStream is2 = loader.getResourceAsStream(EXTRACT_FILE);
if (is2 == null) {
throw new RuntimeException("Schema extract binding definition not found");
}
// process the binding
BoundClass.reset();
MungedClass.reset();
BindingDefinition.reset();
BindingDefinition def1 = Utility.loadBinding(BINDING_FILE, BINDING_NAME, is1, null, true);
BindingDefinition def2 = Utility.loadBinding(EXTRACT_FILE, EXTRACT_NAME, is2, null, true);
def1.generateCode(false, false);
def2.generateCode(false, false);
// finish binding factory with information on classes used
ClassFile[][] lists = MungedClass.fixDispositions();
def1.addClassList(lists[0], lists[1]);
def2.addClassList(lists[0], lists[1]);
// output the modified class files
MungedClass.writeChanges();
// look up the mapped class and associated binding factory
Class mclas = Class.forName(SCHEMA_CLASS);
factory = BindingDirectory.getFactory(BINDING_NAME, mclas);
} catch (JiBXException e) {
throw new RuntimeException("JiBXException: " + e.getMessage());
} catch (IOException e) {
throw new RuntimeException("IOException: " + e.getMessage());
} catch (ClassNotFoundException e) {
throw new RuntimeException("ClassNotFoundException: " + e.getMessage());
}
}
m_bindingFactory = factory;
}
protected ValidationContext m_validationContext;
protected NameRegister m_nameRegister;
protected void setUp() throws Exception {
m_validationContext = new ValidationContext();
}
/**
* Read a schema definition into model.
*
* @param is schema input stream
* @param vctx validation context
* @return schema element
* @throws Exception
*/
protected SchemaElement readSchema(InputStream is, ValidationContext vctx) throws Exception {
final IUnmarshallingContext ictx = m_bindingFactory.createUnmarshallingContext();
ictx.setDocument(is, null);
ictx.setUserContext(vctx);
SchemaElement schema = (SchemaElement)ictx.unmarshalElement();
m_nameRegister = schema.getRegister();
return schema;
}
/**
* Read a schema definition into model.
*
* @param text schema text
* @param vctx validation context
* @return schema element
* @throws Exception
*/
protected SchemaElement readSchema(String text, ValidationContext vctx) throws Exception {
return readSchema(new ByteArrayInputStream(text.getBytes("utf-8")), vctx);
}
/**
* Validate a schema definition.
*
* @param schema schema element
* @param vctx validation context
*/
protected void validateSchema(SchemaElement schema, ValidationContext vctx) {
TreeWalker tctx = new TreeWalker(vctx, vctx);
tctx.walkSchema(schema, new PrevalidationVisitor(vctx));
vctx.clearTraversed();
tctx.walkSchema(schema, new NameRegistrationVisitor(vctx));
vctx.clearTraversed();
tctx.walkSchema(schema, new NameMergeVisitor(vctx));
vctx.clearTraversed();
tctx.walkSchema(schema, new ValidationVisitor(vctx));
}
/**
* Check for validation problem.
*
* @param vctx
* @return true if any problem
*/
protected boolean hasProblem(ValidationContext vctx) {
return vctx.getProblems().size() > 0;
}
/**
* Get validation problem report.
*
* @param vctx
* @return problem text
*/
protected String getProblemText(ValidationContext vctx) {
StringWriter writer = new StringWriter();
writer.append("Problems found in schema definition");
ArrayList problems = vctx.getProblems();
for (int i = 0; i < problems.size(); i++) {
writer.append('\n');
ValidationProblem prob = (ValidationProblem)problems.get(i);
writer.append(prob.getDescription());
}
return writer.toString();
}
/**
* Write schema to text string.
*
* @param schema schema element
* @return output schema text
* @throws Exception
*/
protected String writeSchema(SchemaElement schema) throws Exception {
StringWriter writer = new StringWriter();
IMarshallingContext ictx = m_bindingFactory.createMarshallingContext();
ictx.setOutput(writer);
ictx.setIndent(2);
ictx.marshalDocument(schema);
return writer.toString();
}
/**
* Verify that output schema matches original input. Fails the test if there's any difference between the two
* versions of the schema.
*
* @param text1 original schema text
* @param text2 output schema text
* @throws Exception
*/
protected void verifySchema(String text1, String text2) throws Exception {
StringReader rdr1 = new StringReader(text1);
StringReader rdr2 = new StringReader(text2);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
PrintStream pstr = new PrintStream(bos);
DocumentComparator comp = new DocumentComparator(pstr);
boolean match = comp.compare(rdr1, rdr2);
if (!match) {
pstr.close();
fail("Error roundtripping schema:\n" + new String(bos.toByteArray()) + "\nOriginal schema:\n" + text1
+ "\nOutput schema:\n" + text2);
}
}
/**
* Read and validate schema, with one or more validation errors expected.
*
* @param text schema text
* @param count number of errors expected
* @param msg text for wrong number of errors found
* @throws Exception on unexpected error
*/
protected void runErrors(String text, int count, String msg) throws Exception {
SchemaElement schema = readSchema(text, m_validationContext);
validateSchema(schema, m_validationContext);
assertEquals(msg, count, m_validationContext.getProblems().size());
}
/**
* Read and validate schema, with a particular validation error expected.
*
* @param text schema text
* @param msg text for wrong number of errors found
* @throws Exception on unexpected error
*/
protected void runOneError(String text, String msg) throws Exception {
SchemaElement schema = readSchema(text, m_validationContext);
validateSchema(schema, m_validationContext);
assertTrue(msg, hasProblem(m_validationContext));
}
/**
* Prepare schema model for use.
*
* @param text schema text
* @return schema
* @throws Exception on unexpected error
*/
protected SchemaElement prepareSchema(String text) throws Exception {
m_validationContext.reset();
SchemaElement schema = readSchema(text, m_validationContext);
validateSchema(schema, m_validationContext);
assertFalse(getProblemText(m_validationContext), hasProblem(m_validationContext));
return schema;
}
/**
* Run schema round-trip with validation, with no validation errors.
*
* @param text schema text
* @return schema
* @throws Exception on unexpected error
*/
protected SchemaElement runNoErrors(String text) throws Exception {
SchemaElement schema = prepareSchema(text);
verifySchema(text, writeSchema(schema));
return schema;
}
/**
* Load and validate schema directly. This takes the root schema resolver as input, and loads the schema along with
* all associated schemas. Only the main schema document is actually validated, though.
*
* @param resolve resolver for all schema texts
* @return root schema
* @throws Exception
*/
protected SchemaElement loadSchema(TestResolver resolve) throws Exception {
SchemaElement schema = readSchema(resolve.getContent(), m_validationContext);
schema.setResolver(resolve);
m_validationContext.setSchema(resolve.getName(), schema);
validateSchema(schema, m_validationContext);
assertFalse(getProblemText(m_validationContext), hasProblem(m_validationContext));
verifySchema(resolve.getText(), writeSchema(schema));
return schema;
}
/**
* Load a code generation customization.
*
* @param text customizations document text
* @return loaded customization
* @throws Exception
*/
protected SchemasetCustom loadCustomization(String text) throws Exception {
SchemasetCustom custom = new SchemasetCustom((SchemasetCustom)null);
IBindingFactory fact = BindingDirectory.getFactory("xsdcodegen_customs_binding",
"org.jibx.schema.codegen.custom");
IUnmarshallingContext ictx = fact.createUnmarshallingContext();
ictx.setDocument(new StringReader(text));
ictx.setUserContext(m_validationContext);
((IUnmarshallable)custom).unmarshal(ictx);
return custom;
}
/**
* Resolver used for handling schema text strings directly.
*/
protected static class TestResolver implements ISchemaResolver
{
/** Schema document. */
private final String m_document;
/** Schema name. */
private final String m_name;
/** Map from schema name to resolver. */
private final Map m_schemaMap;
public TestResolver(String document, String name, Map map) {
m_document = document;
m_name = name;
m_schemaMap = map;
}
public InputStream getContent() throws IOException {
return new ByteArrayInputStream(m_document.getBytes("UTF-8"));
}
public String getId() {
return m_name;
}
public String getName() {
return m_name;
}
public ISchemaResolver resolve(String loc, String tns) throws IOException {
return (ISchemaResolver)m_schemaMap.get(loc);
}
public String getText() {
return m_document;
}
}
} libjibx1.2-java-1.2.3/build/test/extras/ 0000755 0001750 0001750 00000000000 11526304016 017620 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/test/extras/binding2.xml 0000644 0001750 0001750 00000001107 10217762724 022047 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/JDOMWriterTest.java 0000644 0001750 0001750 00000036755 10271503144 023270 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import junit.framework.TestCase;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.XMLOutputter;
import org.jibx.extras.JDOMWriter;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.JiBXException;
/**
* JUnit TestCase against JDOMWriter.
*
* Most tests marshal a JDOMContact object to a JDOM Document and
* compare it to a Document based on a static XML file.
*
* As JDOMs equals() methods are based on identity comparison is done using
* XMLOutputter and comparing the resulting Strings.
*
* @author Andreas Brenk
* @version 1.0
*/
public class JDOMWriterTest extends TestCase {
private static final String FIRSTNAME = "Tom";
private static final String LASTNAME = "Sawyer";
private static final String PHONE = "1-800-555-1212";
private static final String INFO1 = "Additional Info First Line";
private static final String INFO2 = "Additional Info Second Line";
private static final String EMPTY_NAMESPACE = "";
private static final String XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
private static final String[] STD_NAMESPACES = new String[] { EMPTY_NAMESPACE, XML_NAMESPACE };
public JDOMWriterTest(String name) {
super(name);
}
/**
* Test a simple binding.
*/
public void testSimpleBinding() throws Exception {
final JDOMContact0 contact = new JDOMContact0(FIRSTNAME, LASTNAME, PHONE);
final Document actualDocument = marshalActualDocument(contact);
final Document expectedDocument = readExpectedOutput("test/extras/jdomcontact0.xml");
final String actualOutput = formatDocument(actualDocument);
final String expectedOutput = formatDocument(expectedDocument);
saveActualOutput(actualOutput);
assertEquals(expectedOutput, actualOutput);
}
/**
* Test a binding with namespaces.
*/
public void testNamespaceBinding() throws Exception {
JDOMContact1 contact = new JDOMContact1(FIRSTNAME, LASTNAME, PHONE, new JDOMContactInformation1(INFO1, INFO2));
final Document actualDocument = marshalActualDocument(contact);
final Document expectedDocument = readExpectedOutput("test/extras/jdomcontact1.xml");
final String actualOutput = formatDocument(actualDocument);
final String expectedOutput = formatDocument(expectedDocument);
saveActualOutput(actualOutput);
assertEquals(expectedOutput, actualOutput);
}
/**
* Test marshalling an object into an existing empty Document.
*/
public void testExistingDocumentWithoutRootNode() throws Exception {
final JDOMContact0 contact = new JDOMContact0(FIRSTNAME, LASTNAME, PHONE);
final Document existingDocument = new Document();
final Document returnedDocument = marshalActualDocument(contact, existingDocument);
final Document expectedDocument = readExpectedOutput("test/extras/jdomcontact0.xml");
final String actualOutput = formatDocument(existingDocument);
final String expectedOutput = formatDocument(expectedDocument);
saveActualOutput(actualOutput);
assertSame(existingDocument, returnedDocument);
assertEquals(expectedOutput, actualOutput);
}
/**
* Test marshalling an object into an existing Document with root Element.
*/
public void testExistingDocumentWithRootNode() throws Exception {
final JDOMContact0 contact = new JDOMContact0(FIRSTNAME, LASTNAME, PHONE);
final Element rootElement = new Element("root");
final Document existingDocument = new Document(rootElement);
final Document returnedDocument = marshalActualDocument(contact, existingDocument);
final Document expectedDocument = readExpectedOutput("test/extras/jdomDocumentContact0.xml");
final String actualOutput = formatDocument(existingDocument);
final String expectedOutput = formatDocument(expectedDocument);
saveActualOutput(actualOutput);
assertSame(existingDocument, returnedDocument);
assertEquals(expectedOutput, actualOutput);
}
/**
* Test marshalling an object into an existing Document with root and content Elements.
*/
public void testExistingDocumentAndCurrentElement() throws Exception {
final JDOMContact0 contact = new JDOMContact0(FIRSTNAME, LASTNAME, PHONE);
final Element rootElement = new Element("root");
final Element currentElement = new Element("current");
rootElement.addContent(new Element("pre").setText("before current"));
rootElement.addContent(currentElement);
rootElement.addContent(new Element("post").setText("after current"));
final Document existingDocument = new Document(rootElement);
final Document returnedDocument = marshalActualDocument(contact, currentElement);
final Document expectedDocument = readExpectedOutput("test/extras/jdomElementContact0.xml");
final String actualOutput = formatDocument(existingDocument);
final String expectedOutput = formatDocument(expectedDocument);
saveActualOutput(actualOutput);
assertSame(existingDocument, returnedDocument);
assertEquals(expectedOutput, actualOutput);
}
/**
* Test valid constructor usages.
*/
public void testValidContructorUsage() throws Exception {
Element element;
Document document;
JDOMWriter jdomWriter = null;
// valid
jdomWriter = new JDOMWriter(STD_NAMESPACES);
jdomWriter = new JDOMWriter(new String[] { EMPTY_NAMESPACE, XML_NAMESPACE, "urn:myNs1", "urn:myNs2" });
document = new Document();
// valid
jdomWriter = new JDOMWriter(STD_NAMESPACES, document);
element = new Element("element");
document = new Document(element);
// valid
jdomWriter = new JDOMWriter(STD_NAMESPACES, document);
jdomWriter = new JDOMWriter(STD_NAMESPACES, element);
assertNotNull(jdomWriter);
}
/**
* Test invalid constructor usages.
*/
public void testInvalidConstructorUsage() throws Exception {
JDOMWriter jdomWriter = null;
// invalid: empty and xml namespace have to be defined
try {
jdomWriter = new JDOMWriter(new String[0]);
fail("expected ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {}
try {
jdomWriter = new JDOMWriter(new String[1]);
fail("expected ArrayIndexOutOfBoundsException");
} catch(ArrayIndexOutOfBoundsException e) {}
// invalid: Document is null
try {
jdomWriter = new JDOMWriter(STD_NAMESPACES, (Document) null);
fail("expected NullPointerException");
} catch(NullPointerException e) {}
// invalid: Element is null
try {
jdomWriter = new JDOMWriter(STD_NAMESPACES, (Element) null);
fail("expected NullPointerException");
} catch(NullPointerException e) {}
// invalid: Element has no parent Document
try {
jdomWriter = new JDOMWriter(STD_NAMESPACES, new Element("element"));
fail("expected NullPointerException");
} catch(NullPointerException e) {}
assertNull(jdomWriter);
}
/**
* Test adding and removing extension namespaces.
*/
public void testExtensionNamespaces() throws Exception {
final JDOMWriter jdomWriter = new JDOMWriter(STD_NAMESPACES);
String[][] ns;
ns = jdomWriter.getExtensionNamespaces();
assertNull(ns);
jdomWriter.pushExtensionNamespaces(new String[] { "urn:myNs1", "urn:myNs2" });
ns = jdomWriter.getExtensionNamespaces();
assertEquals(1, ns.length);
assertEquals("urn:myNs1", ns[0][0]);
assertEquals("urn:myNs2", ns[0][1]);
jdomWriter.pushExtensionNamespaces(new String[] { "urn:myNs3" });
ns = jdomWriter.getExtensionNamespaces();
assertEquals(2, ns.length);
assertEquals(2, ns[0].length);
assertEquals(1, ns[1].length);
assertEquals("urn:myNs1", ns[0][0]);
assertEquals("urn:myNs2", ns[0][1]);
assertEquals("urn:myNs3", ns[1][0]);
jdomWriter.popExtensionNamespaces();
ns = jdomWriter.getExtensionNamespaces();
assertEquals(1, ns.length);
assertEquals(2, ns[0].length);
assertEquals("urn:myNs1", ns[0][0]);
assertEquals("urn:myNs2", ns[0][1]);
jdomWriter.popExtensionNamespaces();
ns = jdomWriter.getExtensionNamespaces();
assertNull(ns);
}
/**
* Test changing namespace prefixes.
*/
public void testNamespacePrefixes() throws Exception {
JDOMWriter jdomWriter = new JDOMWriter(new String[] { EMPTY_NAMESPACE, XML_NAMESPACE, "urn:myNs1", "urn:myNs2" });
assertEquals("", jdomWriter.getNamespaceUri(0));
assertEquals("http://www.w3.org/XML/1998/namespace", jdomWriter.getNamespaceUri(1));
assertEquals("urn:myNs1", jdomWriter.getNamespaceUri(2));
assertEquals("urn:myNs2", jdomWriter.getNamespaceUri(3));
assertEquals("", jdomWriter.getNamespacePrefix(0));
assertEquals("xml", jdomWriter.getNamespacePrefix(1));
assertNull("unexpected prefix defined", jdomWriter.getNamespacePrefix(2));
assertNull("unexpected prefix defined", jdomWriter.getNamespacePrefix(3));
jdomWriter.startTagNamespaces(0, "element1", new int[] {2, 3}, new String[] {"myns1", "myns2"});
jdomWriter.closeStartTag();
assertEquals("myns1", jdomWriter.getNamespacePrefix(2));
assertEquals("myns2", jdomWriter.getNamespacePrefix(3));
jdomWriter.startTagNamespaces(0, "element2", new int[] {2}, new String[] {"prefix"});
assertEquals("prefix", jdomWriter.getNamespacePrefix(2));
assertEquals("myns2", jdomWriter.getNamespacePrefix(3));
jdomWriter.closeEmptyTag();
assertEquals("myns1", jdomWriter.getNamespacePrefix(2));
assertEquals("myns2", jdomWriter.getNamespacePrefix(3));
jdomWriter.endTag(0, "element1");
assertNull("unexpected prefix defined", jdomWriter.getNamespacePrefix(2));
assertNull("unexpected prefix defined", jdomWriter.getNamespacePrefix(3));
}
/**
* Helper method to read a file to a Document.
*
* @param filename the name of a XML file to read
* @return a Document based on the given file
*/
private static Document readExpectedOutput(String filename) throws IOException, JDOMException {
final SAXBuilder builder = new SAXBuilder();
final InputStream input = new FileInputStream(filename);
return builder.build(input);
}
/**
* Helper method to format a Document to String.
*
* @param document the Document to format
* @return a String containing XML
*/
private static String formatDocument(Document document) throws IOException {
final XMLOutputter outputter = new XMLOutputter();
final StringWriter writer = new StringWriter();
outputter.output(document, writer);
return writer.getBuffer().toString();
}
/**
* Helper method to marshal an Object to a Document.
*
* @param root the Object to marshal
* @return the Document representation
*/
private static Document marshalActualDocument(Object root) throws JiBXException {
final IBindingFactory bfact = BindingDirectory.getFactory(root.getClass());
final IMarshallingContext mctx = bfact.createMarshallingContext();
final JDOMWriter jdomWriter = new JDOMWriter(bfact.getNamespaces());
return marshalDocument(root, mctx, jdomWriter);
}
private static Document marshalActualDocument(Object root, Document document) throws JiBXException {
final IBindingFactory bfact = BindingDirectory.getFactory(root.getClass());
final IMarshallingContext mctx = bfact.createMarshallingContext();
final JDOMWriter jdomWriter = new JDOMWriter(bfact.getNamespaces(), document);
return marshalDocument(root, mctx, jdomWriter);
}
private static Document marshalActualDocument(Object root, Element element) throws JiBXException {
final IBindingFactory bfact = BindingDirectory.getFactory(root.getClass());
final IMarshallingContext mctx = bfact.createMarshallingContext();
final JDOMWriter jdomWriter = new JDOMWriter(bfact.getNamespaces(), element);
return marshalDocument(root, mctx, jdomWriter);
}
private static Document marshalDocument(Object root, IMarshallingContext mctx, JDOMWriter jdomWriter) throws JiBXException {
mctx.setXmlWriter(jdomWriter);
mctx.marshalDocument(root);
return jdomWriter.getDocument();
}
/**
* Helper method to save the actual output to temp.xml
*
* @param actualOutput the output generated by marshalling
*/
private static void saveActualOutput(String actualOutput) throws IOException {
File fout = new File("temp.xml");
fout.delete();
FileOutputStream fos = new FileOutputStream(fout);
fos.write(actualOutput.getBytes());
fos.close();
}
}
libjibx1.2-java-1.2.3/build/test/extras/binding3.xml 0000644 0001750 0001750 00000001054 10217762724 022051 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/contact0c.xml 0000644 0001750 0001750 00000000455 11335361750 022232 0 ustar twerner twerner
TomSawyer1-800-555-1212
kadfadadfadf
libjibx1.2-java-1.2.3/build/test/extras/JDOMContactInformation1.java 0000644 0001750 0001750 00000003550 10267761534 025037 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
/**
* @author Andreas Brenk
*/
public class JDOMContactInformation1
{
private String additionalInfo1;
private String additionalInfo2;
public JDOMContactInformation1() {}
public JDOMContactInformation1(String additionalInfo1, String additionalInfo2) {
this.additionalInfo1 = additionalInfo1;
this.additionalInfo2 = additionalInfo2;
}
}
libjibx1.2-java-1.2.3/build/test/extras/contact0b.xml 0000644 0001750 0001750 00000000326 11335263506 022226 0 ustar twerner twerner
TomSawyer1-800-555-1212
kadfadadfadf
libjibx1.2-java-1.2.3/build/test/extras/binding3b.xml 0000644 0001750 0001750 00000001127 10217762724 022214 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/jdomDocumentContact0.xml 0000644 0001750 0001750 00000000236 10267761534 024404 0 ustar twerner twerner
TomSawyer1-800-555-1212
libjibx1.2-java-1.2.3/build/test/extras/contact0a.xml 0000644 0001750 0001750 00000000306 11335263450 022221 0 ustar twerner twerner
TomSawyer1-800-555-1212
kadfadadfadf
libjibx1.2-java-1.2.3/build/test/extras/contact3.xml 0000644 0001750 0001750 00000005112 10071714432 022060 0 ustar twerner twerner
TomSawyer1-800-555-1212
Performance tests
For performance tests of the data binding frameworks I generated documents
containing mock airline flight timetable information. These are based
on the same structure I defined in the earlier article on mapped
data binding with Castor. Here's a sample of that structure, herein referred
to as the "compact" format because it uses mainly attributes for data:
Listing 1. Compact document format<?xml version="1.0"?>
<timetable>
<carrier ident="AR" rating="9">
<URL>http://www.arcticairlines.com</URL>
<name>Arctic Airlines</name>
</carrier>
<carrier ident="CA" rating="7">
<URL>http://www.combinedlines.com</URL>
<name>Combined Airlines</name>
</carrier>
<airport ident="SEA">
<location>Seattle, WA</location>
<name>Seattle-Tacoma International Airport</name>
</airport>
<airport ident="LAX">
<location>Los Angeles, CA</location>
<name>Los Angeles International Airport</name>
</airport>
<route from="SEA" to="LAX">
<flight carrier="AR" depart="6:23a" arrive="8:42a" number="426"/>
<flight carrier="CA" depart="8:10a" arrive="10:52a" number="833"/>
<flight carrier="AR" depart="9:00a" arrive="11:36a" number="433"/>
</route>
<route from="LAX" to="SEA">
<flight carrier="CA" depart="7:45a" arrive="10:20a" number="311"/>
<flight carrier="AR" depart="9:27a" arrive="12:04p" number="593"/>
<flight carrier="AR" depart="12:30p" arrive="3:07p" number="102"/>
</route>
</timetable>
libjibx1.2-java-1.2.3/build/test/extras/contact1a.xml 0000644 0001750 0001750 00000000536 11335264110 022221 0 ustar twerner twerner
TomSawyer1-800-555-1212
12345 Happy Lane
Plunk
WA
98059
libjibx1.2-java-1.2.3/build/test/extras/bindingdom4j1.xml 0000644 0001750 0001750 00000000746 10071714432 023003 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/binding3a.xml 0000644 0001750 0001750 00000001407 10217762724 022214 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/Dom4JContact1.java 0000644 0001750 0001750 00000003223 10071714430 022774 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
import org.dom4j.Element;
public class Dom4JContact1
{
public String m_firstName;
public String m_lastName;
public String m_phone;
public Element m_information;
}
libjibx1.2-java-1.2.3/build/test/extras/binding9.xml 0000644 0001750 0001750 00000001015 10257173436 022054 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/bindingjdom1.xml 0000644 0001750 0001750 00000001107 10267761534 022723 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/names3.xml 0000644 0001750 0001750 00000000762 10217762724 021547 0 ustar twerner twerner
TomSawyer
GeorgeSmith
AdamSmith
HuckFinn
libjibx1.2-java-1.2.3/build/test/extras/bindingdom4j2.xml 0000644 0001750 0001750 00000000733 10071714432 023000 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/binding4.xml 0000644 0001750 0001750 00000001077 10217762724 022057 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/binding0.xml 0000644 0001750 0001750 00000001063 10217762724 022046 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/bindingdom0.xml 0000644 0001750 0001750 00000000762 10071714432 022542 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/binding10.xml 0000644 0001750 0001750 00000001105 10270123702 022106 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/bindingdom3.xml 0000644 0001750 0001750 00000000737 10071714432 022547 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/ValueMap.java 0000644 0001750 0001750 00000003452 10222700120 022165 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
import java.util.Hashtable;
import java.util.Map;
public class ValueMap
{
public Map m_map = new Hashtable();
private void postSet() {
if (!(m_map instanceof Hashtable)) {
throw new IllegalStateException
("Original object not passed for custom unmarshaller");
}
}
}
libjibx1.2-java-1.2.3/build/test/extras/Dom4JContact0.java 0000644 0001750 0001750 00000003167 10071714430 023002 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
public class Dom4JContact0
{
public String m_firstName;
public String m_lastName;
public String m_phone;
public Object m_information;
}
libjibx1.2-java-1.2.3/build/test/extras/names1.xml 0000644 0001750 0001750 00000000542 10217762724 021541 0 ustar twerner twerner
TomSawyer
GeorgeSmith
AdamSmith
HuckFinn
libjibx1.2-java-1.2.3/build/test/extras/contact2.xml 0000644 0001750 0001750 00000002753 10071714432 022067 0 ustar twerner twerner
TomSawyer1-800-555-1212
2001-07-02T04:33:22.610Z
152.46613
78.09824
2001-05-04T02:31:00.601Z
-48.434654
-91.997185
libjibx1.2-java-1.2.3/build/test/extras/DomContact2.java 0000644 0001750 0001750 00000003642 10071714430 022604 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
import java.util.List;
public class DomContact2 implements org.jibx.runtime.impl.ITrackSourceImpl
{
public String m_firstName;
public String m_lastName;
public String m_phone;
public List m_information;
public String jibx_getDocumentName() { return null; }
public int jibx_getLineNumber() { return 0; }
public int jibx_getColumnNumber() { return 0; }
public void jibx_setSource(String name, int line, int column) {}
}
libjibx1.2-java-1.2.3/build/test/extras/binding7.xml 0000644 0001750 0001750 00000000765 10071714432 022054 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/values0.xml 0000644 0001750 0001750 00000000613 10311007620 021711 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/Dom4JContact2.java 0000644 0001750 0001750 00000003215 10071714430 022776 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
import java.util.List;
public class Dom4JContact2
{
public String m_firstName;
public String m_lastName;
public String m_phone;
public List m_information;
}
libjibx1.2-java-1.2.3/build/test/extras/contact1.xml 0000644 0001750 0001750 00000000415 10071714432 022057 0 ustar twerner twerner
TomSawyer1-800-555-1212
12345 Happy Lane
Plunk
WA
98059
libjibx1.2-java-1.2.3/build/test/extras/QNameReference.java 0000644 0001750 0001750 00000007316 10270123702 023306 0 ustar twerner twerner /*
Copyright (c) 2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
import java.io.IOException;
import java.util.ArrayList;
import org.jibx.extras.QName;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.IXMLWriter;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.MarshallingContext;
import org.jibx.runtime.impl.UnmarshallingContext;
public class QNameReference
{
protected QName m_ref1;
protected QName m_ref2;
protected QName m_ref3;
protected ArrayList m_namespaces;
protected QName getRef() {
return m_ref3;
}
protected void setRef(QName qname) {
m_ref3 = qname;
}
protected void getNamespaces(IUnmarshallingContext ictx)
throws JiBXException {
UnmarshallingContext ctx = (UnmarshallingContext)ictx;
int count = ctx.getNamespaceCount();
if (count > 0) {
m_namespaces = new ArrayList();
for (int i = 0; i < count; i++) {
m_namespaces.add(ctx.getNamespacePrefix(i));
m_namespaces.add(ctx.getNamespaceUri(i));
}
} else {
m_namespaces = null;
}
}
protected void setNamespaces(IMarshallingContext ictx) throws IOException {
if (m_namespaces != null) {
IXMLWriter writer = ((MarshallingContext)ictx).getXmlWriter();
String[] uris = new String[m_namespaces.size()/2];
int[] indexes = new int[uris.length];
String[] prefs = new String[uris.length];
int base = writer.getNamespaceCount();
for (int i = 0; i < uris.length; i++) {
indexes[i] = base + i;
String pref = (String)m_namespaces.get(i*2);
if (pref == null) {
pref = "";
}
prefs[i] = pref;
uris[i] = (String)m_namespaces.get(i*2+1);
}
writer.pushExtensionNamespaces(uris);
writer.openNamespaces(indexes, prefs);
for (int i = 0; i < uris.length; i++) {
String prefix = prefs[i];
String name = prefix.length() > 0 ? "xmlns:" + prefix : "xmlns";
writer.addAttribute(0, name, uris[i]);
}
}
}
} libjibx1.2-java-1.2.3/build/test/extras/NameArray.java 0000644 0001750 0001750 00000004572 10217762724 022364 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
import java.util.ArrayList;
import org.jibx.extras.IdDefRefMapperBase;
import org.jibx.extras.IdRefMapperBase;
public class NameArray
{
public Object[] m_names;
public ArrayList m_references;
public static class Name
{
public String m_id;
public String m_first;
public String m_last;
}
private static class RefMapper extends IdRefMapperBase
{
public RefMapper(String uri, int index, String name) {
super(uri, index, name);
}
protected String getIdValue(Object item) {
return ((Name)item).m_id;
}
}
private static class DefRefMapper extends IdDefRefMapperBase
{
public DefRefMapper(String uri, int index, String name) {
super(uri, index, name);
}
protected String getIdValue(Object item) {
return ((Name)item).m_id;
}
}
}
libjibx1.2-java-1.2.3/build/test/extras/JDOMContact1.java 0000644 0001750 0001750 00000003725 10267761534 022635 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
/**
* @author Andreas Brenk
*/
public class JDOMContact1
{
private String firstName;
private String lastName;
private String phone;
private JDOMContactInformation1 information;
public JDOMContact1() {}
public JDOMContact1(String firstName, String lastName, String phone, JDOMContactInformation1 information) {
this.firstName = firstName;
this.lastName = lastName;
this.phone = phone;
this.information = information;
}
}
libjibx1.2-java-1.2.3/build/test/extras/bindingdom4j0.xml 0000644 0001750 0001750 00000000746 10071714432 023002 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/jdomcontact0.xml 0000644 0001750 0001750 00000000221 10267761534 022737 0 ustar twerner twerner
TomSawyer1-800-555-1212
libjibx1.2-java-1.2.3/build/test/extras/qnames1.xml 0000644 0001750 0001750 00000000245 10267761460 021723 0 ustar twerner twerner
ns1:qname
ns2:qname
libjibx1.2-java-1.2.3/build/test/extras/DomContact3.java 0000644 0001750 0001750 00000003245 10071714430 022604 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
import org.w3c.dom.DocumentFragment;
public class DomContact3
{
public String m_firstName;
public String m_lastName;
public String m_phone;
public DocumentFragment m_information;
}
libjibx1.2-java-1.2.3/build/test/extras/jdomcontact1.xml 0000644 0001750 0001750 00000000556 10267761534 022753 0 ustar twerner twerner
TomSawyer1-800-555-1212Additional Info First LineAdditional Info Second Line
libjibx1.2-java-1.2.3/build/test/extras/binding1.xml 0000644 0001750 0001750 00000001010 10217762724 022037 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/names3b.xml 0000644 0001750 0001750 00000000720 10217762724 021703 0 ustar twerner twerner
TomSawyer
GeorgeSmith
AdamSmith
HuckFinn
libjibx1.2-java-1.2.3/build/test/extras/qnames2.xml 0000644 0001750 0001750 00000000211 10267761460 021715 0 ustar twerner twerner
ns2:qname
ns3:qname
libjibx1.2-java-1.2.3/build/test/extras/contact1b.xml 0000644 0001750 0001750 00000000560 11335265214 022225 0 ustar twerner twerner
TomSawyer1-800-555-1212
12345 Happy Lane
Plunk
WA
98059
libjibx1.2-java-1.2.3/build/test/extras/contact2a.xml 0000644 0001750 0001750 00000002753 11335264316 022235 0 ustar twerner twerner
TomSawyer1-800-555-1212
2001-07-02T04:33:22.610Z
152.46613
78.09824
2001-05-04T02:31:00.601Z
-48.434654
-91.997185
libjibx1.2-java-1.2.3/build/test/extras/bindingjdom0.xml 0000644 0001750 0001750 00000000341 10267761534 022721 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/names2.xml 0000644 0001750 0001750 00000000577 10217762724 021552 0 ustar twerner twerner
TomSawyer
GeorgeSmith
AdamSmith
HuckFinn
libjibx1.2-java-1.2.3/build/test/extras/DomContact1.java 0000644 0001750 0001750 00000003223 10071714430 022576 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
import org.w3c.dom.Element;
public class DomContact1
{
public String m_firstName;
public String m_lastName;
public String m_phone;
public Element m_information;
}
libjibx1.2-java-1.2.3/build/test/extras/Contact0.java 0000644 0001750 0001750 00000003264 10071714430 022142 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
public class Contact0
{
public String m_firstName;
public String m_lastName;
public String m_phone;
private void setIgnored(Object ignore) {}
private Object getIgnored() { return null; }
} libjibx1.2-java-1.2.3/build/test/extras/bindingdom2.xml 0000644 0001750 0001750 00000000747 10071714432 022547 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/names0.xml 0000644 0001750 0001750 00000000011 10071714432 021516 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/bindingdom1.xml 0000644 0001750 0001750 00000000763 10071714432 022544 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/contact0.xml 0000644 0001750 0001750 00000000156 10071714432 022060 0 ustar twerner twerner
TomSawyer1-800-555-1212
libjibx1.2-java-1.2.3/build/test/extras/DomContact0.java 0000644 0001750 0001750 00000003165 10071714430 022602 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
public class DomContact0
{
public String m_firstName;
public String m_lastName;
public String m_phone;
public Object m_information;
}
libjibx1.2-java-1.2.3/build/test/extras/TypedArray.java 0000644 0001750 0001750 00000004425 10217762724 022566 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
import org.jibx.extras.IdRefMapperBase;
public class TypedArray
{
public Name[] m_names;
public Name[] getNames() {
return m_names;
}
public void setNames(Name[] array) {
m_names = array;
}
public Object[] getObjects() {
return m_names;
}
public void setObjects(Object[] array) {
m_names = (Name[])array;
}
public static class Name
{
public String m_id;
public String m_first;
public String m_last;
}
private static class RefMapper extends IdRefMapperBase
{
public RefMapper(String uri, int index, String name) {
super(uri, index, name);
}
protected String getIdValue(Object item) {
return ((Name)item).m_id;
}
}
}
libjibx1.2-java-1.2.3/build/test/extras/binding6.xml 0000644 0001750 0001750 00000001001 10071714432 022033 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/jdomElementContact0.xml 0000644 0001750 0001750 00000000344 10267761534 024217 0 ustar twerner twerner
before current
TomSawyer1-800-555-1212after current
libjibx1.2-java-1.2.3/build/test/extras/contact3a.xml 0000644 0001750 0001750 00000007707 11335264410 022235 0 ustar twerner twerner
TomSawyer1-800-555-1212
Performance tests
For performance tests of the data binding frameworks I generated documents
containing mock airline flight timetable information. These are based
on the same structure I defined in the earlier article on mapped
data binding with Castor. Here's a sample of that structure, herein referred
to as the "compact" format because it uses mainly attributes for data:
Listing 1. Compact document format<?xml version="1.0"?>
<timetable>
<carrier ident="AR" rating="9">
<URL>http://www.arcticairlines.com</URL>
<name>Arctic Airlines</name>
</carrier>
<carrier ident="CA" rating="7">
<URL>http://www.combinedlines.com</URL>
<name>Combined Airlines</name>
</carrier>
<airport ident="SEA">
<location>Seattle, WA</location>
<name>Seattle-Tacoma International Airport</name>
</airport>
<airport ident="LAX">
<location>Los Angeles, CA</location>
<name>Los Angeles International Airport</name>
</airport>
<route from="SEA" to="LAX">
<flight carrier="AR" depart="6:23a" arrive="8:42a" number="426"/>
<flight carrier="CA" depart="8:10a" arrive="10:52a" number="833"/>
<flight carrier="AR" depart="9:00a" arrive="11:36a" number="433"/>
</route>
<route from="LAX" to="SEA">
<flight carrier="CA" depart="7:45a" arrive="10:20a" number="311"/>
<flight carrier="AR" depart="9:27a" arrive="12:04p" number="593"/>
<flight carrier="AR" depart="12:30p" arrive="3:07p" number="102"/>
</route>
</timetable>
2001-07-02T04:33:22.610Z
152.46613
78.09824
2001-05-04T02:31:00.601Z
-48.434654
-91.997185
libjibx1.2-java-1.2.3/build/test/extras/JDOMContact0.java 0000644 0001750 0001750 00000003527 10267761534 022634 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 extras;
/**
* @author Andreas Brenk
*/
public class JDOMContact0
{
private String firstName;
private String lastName;
private String phone;
public JDOMContact0() {}
public JDOMContact0(String firstName, String lastName, String phone) {
this.firstName = firstName;
this.lastName = lastName;
this.phone = phone;
}
}
libjibx1.2-java-1.2.3/build/test/extras/binding8.xml 0000644 0001750 0001750 00000000721 10222700116 022035 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/extras/values1.xml 0000644 0001750 0001750 00000000734 10311007620 021716 0 ustar twerner twerner
2004-08-06T00:13:31.587Z
0.0
0
string0
libjibx1.2-java-1.2.3/build/test/extras/binding5.xml 0000644 0001750 0001750 00000001207 10217762724 022053 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/binding5b-include1.xml 0000644 0001750 0001750 00000001565 10257173436 022420 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/ 0000755 0001750 0001750 00000000000 11526304016 017603 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/test/simple/mytest5.xml 0000644 0001750 0001750 00000000143 10222705000 021723 0 ustar twerner twerner
efgh
libjibx1.2-java-1.2.3/build/test/simple/Customer6b.java 0000644 0001750 0001750 00000003223 10756367204 022513 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class Customer6b extends Customer6bBase implements ICustomer6a
{
public long customerId;
public boolean repeat;
public int orderCount;
public float discount;
}
libjibx1.2-java-1.2.3/build/test/simple/binding3d.xml 0000644 0001750 0001750 00000001313 10264375570 022177 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding2.xml 0000644 0001750 0001750 00000001277 10071714446 022036 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple2b.xml 0000644 0001750 0001750 00000000460 11140052364 022040 0 ustar twerner twerner ÿþ< c u s t o m e r >
< s t r e e t 1 > 1 2 3 4 5 H a p p y L a n e < / s t r e e t 1 >
< c i t y > P l u n k < / c i t y >
< s t a t e > W A < / s t a t e >
< z i p > 9 8 0 5 9 < / z i p >
< p h o n e > 8 8 8 . 5 5 5 . 1 2 3 4 < / p h o n e >
< / c u s t o m e r >
libjibx1.2-java-1.2.3/build/test/simple/ICustomer8b.java 0000644 0001750 0001750 00000003005 10221061172 022602 0 ustar twerner twerner /*
Copyright (c) 2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public interface ICustomer8b
{
} libjibx1.2-java-1.2.3/build/test/simple/mytest3d.xml 0000644 0001750 0001750 00000000215 11124406456 022104 0 ustar twerner twerner
The Answer
22
33
libjibx1.2-java-1.2.3/build/test/simple/mybinding5a.xml 0000644 0001750 0001750 00000002055 10677535700 022551 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/Address.java 0000644 0001750 0001750 00000003156 10330637714 022046 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class Address
{
private Address() {}
public String street1;
public String city;
public String state;
public String zip;
}
libjibx1.2-java-1.2.3/build/test/simple/binding3.xml 0000644 0001750 0001750 00000001603 10264375570 022035 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/ICustomer8.java 0000644 0001750 0001750 00000003522 10217763160 022457 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public interface ICustomer8
{
public String getId();
public Name getName();
public String getStreet();
public String getCity();
public String getState();
public void setId(String id);
public void setName(Name name);
public void setStreet(String value);
public void setCity(String value);
public void setState(String value);
} libjibx1.2-java-1.2.3/build/test/simple/mybinding6d.xml 0000644 0001750 0001750 00000002037 11037475152 022550 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mybinding7d.xml 0000644 0001750 0001750 00000002751 11262212046 022543 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/MyClass5.java 0000644 0001750 0001750 00000006657 10425211274 022124 0 ustar twerner twerner
package simple;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;
import org.jibx.runtime.IUnmarshallingContext;
public class MyClass5 {
private ArrayList childs1;
private ArrayList childs2;
private ArrayList childs3;
private Set altchilds2;
private Set altchilds3;
private void unmarshalDone() {
for (int i = 0; i < childs1.size(); i++) {
((MyClass5a)childs1.get(i)).verify();
}
if (childs2 != null) {
for (int i = 0; i < childs2.size(); i++) {
((MyClass5a)childs2.get(i)).verify();
}
}
if (childs3 != null) {
for (int i = 0; i < childs3.size(); i++) {
((MyClass5a)childs3.get(i)).verify();
}
}
}
private static MyClass5a bFactory() {
MyClass5b inst = new MyClass5b();
inst.factory = true;
return inst;
}
private static MyClass5a cFactory(Object obj) {
if (!(obj instanceof ArrayList)) {
throw new IllegalStateException("factory called with wrong object");
}
MyClass5c inst = new MyClass5c();
inst.factory = true;
return inst;
}
private static MyClass5a dFactory(IUnmarshallingContext ctx) {
if (!(ctx.getStackObject(1) instanceof MyClass5)) {
throw new IllegalStateException("wrong object in stack");
}
MyClass5d inst = new MyClass5d();
inst.factory = true;
return inst;
}
private static Set setFactory() {
return new OrderedSet();
}
private static class OrderedSet implements Set
{
private final ArrayList list;
private OrderedSet() {
list = new ArrayList();
}
private OrderedSet(OrderedSet original) {
list = new ArrayList(original.list);
}
public boolean add(Object arg0) {
return list.add(arg0);
}
public boolean addAll(Collection arg0) {
return list.addAll(arg0);
}
public void clear() {
list.clear();
}
public Object clone() {
return new OrderedSet(this);
}
public boolean contains(Object elem) {
return list.contains(elem);
}
public boolean containsAll(Collection arg0) {
return list.containsAll(arg0);
}
public boolean equals(Object o) {
if (o instanceof OrderedSet) {
return ((OrderedSet)o).list.equals(list);
} else {
return false;
}
}
public int hashCode() {
return list.hashCode();
}
public boolean isEmpty() {
return list.isEmpty();
}
public Iterator iterator() {
return list.iterator();
}
public boolean remove(Object o) {
return list.remove(o);
}
public boolean removeAll(Collection arg0) {
return list.removeAll(arg0);
}
public boolean retainAll(Collection arg0) {
return list.retainAll(arg0);
}
public int size() {
return list.size();
}
public Object[] toArray() {
return list.toArray();
}
public Object[] toArray(Object[] arg0) {
return list.toArray(arg0);
}
public String toString() {
return list.toString();
}
}
}
libjibx1.2-java-1.2.3/build/test/simple/Customers6.java 0000644 0001750 0001750 00000005002 10071714444 022521 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
import java.util.Iterator;
public class Customers6
{
private int fillPosition;
private Object[] customers;
private void setCustomerCount(int count) {
customers = new Object[count];
fillPosition = 0;
}
private int getCustomerCount() {
return fillPosition;
}
private void addCustomer(Object obj) {
customers[fillPosition++] = obj;
}
private Iterator getCustomerIterator() {
return new CustomerIterator();
}
private class CustomerIterator implements Iterator {
int nextIndex;
private CustomerIterator() {
nextIndex = 0;
}
public boolean hasNext() {
return nextIndex < fillPosition;
}
public Object next() {
if (nextIndex < fillPosition) {
return customers[nextIndex++];
} else {
return null;
}
}
public void remove() {
throw new UnsupportedOperationException("No remove support");
}
}
}
libjibx1.2-java-1.2.3/build/test/simple/binding7b.xml 0000644 0001750 0001750 00000002306 10257173436 022203 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple7.xml 0000644 0001750 0001750 00000000741 10071714452 021712 0 ustar twerner twerner
3
12345 Happy Lane
Plunk
12345 Happy Lane
Plunk
12345 Plunket Lane
Happy
libjibx1.2-java-1.2.3/build/test/simple/Customer5.java 0000644 0001750 0001750 00000003404 10071714444 022341 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
import java.util.ArrayList;
public class Customer5 extends Customer5Base
{
public long customerId;
public boolean repeat;
public short orderCount;
public double discount;
// items in array can be Customer5a, Customer5b, and Customer5c (that order)
public ArrayList referrals;
}
libjibx1.2-java-1.2.3/build/test/simple/binding5a.xml 0000644 0001750 0001750 00000004544 10305515602 022173 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mybinding7c.xml 0000644 0001750 0001750 00000002000 11262224722 022531 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/Identity10.java 0000644 0001750 0001750 00000000120 11046604540 022373 0 ustar twerner twerner package simple;
public class Identity10 {
public Integer customerNumber;
}
libjibx1.2-java-1.2.3/build/test/simple/NamePrivate.java 0000644 0001750 0001750 00000003122 10330637714 022665 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class NamePrivate
{
private NamePrivate() {}
public String firstName;
public String lastName;
}
libjibx1.2-java-1.2.3/build/test/simple/simple8.xml 0000644 0001750 0001750 00000002303 10217763160 021711 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98022
Mary
Smith
12345 Happy Lane
Plunk
WA
98022
Larry
Adams
12345 Plunket Lane
Happy
WA
98095
Gary
Adams
12345 Plunket Lane
Happy
WA
98095
libjibx1.2-java-1.2.3/build/test/simple/mytest6c.xml 0000644 0001750 0001750 00000000325 10071714452 022106 0 ustar twerner twerner
this is a test
so is this
this is not a test
1
2
3
1234567890
libjibx1.2-java-1.2.3/build/test/simple/ICustomer8c.java 0000644 0001750 0001750 00000003005 10221061172 022603 0 ustar twerner twerner /*
Copyright (c) 2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public interface ICustomer8c
{
} libjibx1.2-java-1.2.3/build/test/simple/Customer8a.java 0000644 0001750 0001750 00000004254 10257173436 022517 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class Customer8a implements ICustomer8
{
protected String id;
protected Name name;
protected String street1;
protected String city;
protected String state;
protected int zip;
public void setId(String value) { id = value; }
public Name getName() { return name; }
public String getStreet() { return street1; }
public String getCity() { return city; }
public String getState() { return state; }
public String getId() { return id; }
public void setName(Name name) { this.name = name; }
public void setStreet(String value) { street1 = value; }
public void setCity(String value) { city = value; }
public void setState(String value) { state = value; }
}
libjibx1.2-java-1.2.3/build/test/simple/NameExtended.java 0000644 0001750 0001750 00000003044 10316003036 023002 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class NameExtended extends Name
{
public String ssn;
}
libjibx1.2-java-1.2.3/build/test/simple/MyClass6.java 0000644 0001750 0001750 00000002164 11037475146 022124 0 ustar twerner twerner
package simple;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
class MyClass6
{
private final List ints = new ArrayList();
private final List strings = new ArrayList();
private byte a;
private boolean b;
private List lists;
public static ArrayList createList() {
throw new IllegalStateException
("Factory method should never be called");
}
protected void setInts(final List list) {
if (list != ints) {
throw new IllegalStateException
("Set method called with different list object");
}
}
private boolean isPresent() {
return ints.size() > 0;
}
private Iterator intsIterator() {
return ints.iterator();
}
private void addInt(Object o) {
ints.add((Integer)o);
}
private void addString(Object o) {
strings.add((String)o);
}
private static class Lists
{
private List list1;
private List list2;
private List list3;
private List list4;
}
}
libjibx1.2-java-1.2.3/build/test/simple/Customer0.java 0000644 0001750 0001750 00000003607 11475010364 022340 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class Customer0
{
public Name name;
public String street1;
public String city;
public String state;
public String zip;
public String phone;
public Customer0() {
name = new Name();
name.firstName = "first";
name.lastName = "last";
}
public void setName(Name name) {
this.name = name;
}
public Name getName() {
return name;
}
}
libjibx1.2-java-1.2.3/build/test/simple/mytest7c.xml 0000644 0001750 0001750 00000002706 10524454344 022120 0 ustar twerner twerner
7
6
4
3
2
this is a test
so is this
this is not a test
some more test
testing, testing, testing
to test or not to test, that is the question
3
4
5
42
73
72653
-1
0
1
42
73
72653
-1
0
1
42.5
73.0
72653.0
-1.5
0.5
1.0
libjibx1.2-java-1.2.3/build/test/simple/simple5.xml 0000644 0001750 0001750 00000002442 10305515602 021704 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.1234
A
Mary
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.4321
Mary
Lamb
333 Fleece St.
Highlant
WA
98088
888.555.8321
Larry
Adams
12345 Plunket Lane
Happy
WA
98095
888.555.9999
A
5
libjibx1.2-java-1.2.3/build/test/simple/mytest3a.xml 0000644 0001750 0001750 00000000316 11124406456 022103 0 ustar twerner twerner
55
true
1
2
3
1234567890
libjibx1.2-java-1.2.3/build/test/simple/binding0b.xml 0000644 0001750 0001750 00000000714 10435066032 022164 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding0c.xml 0000644 0001750 0001750 00000001022 10435066032 022156 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/Name.java 0000644 0001750 0001750 00000004071 11153073776 021344 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class Name
{
/*package*/ Name() {}
private boolean ifFirst;
public String firstName;
private boolean ifLast;
public String lastName;
private void setFirst(String name) {
firstName = name;
}
private void setLast(String name) {
lastName = name;
}
private boolean isFirst() {
return ifFirst;
}
private void flagFirst(boolean flag) {
ifFirst = flag;
}
private boolean isLast() {
return ifLast;
}
private void flagLast(boolean flag) {
ifLast = flag;
}
}
libjibx1.2-java-1.2.3/build/test/simple/mytest6.xml 0000644 0001750 0001750 00000000052 10071714452 021740 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mytest7d.xml 0000644 0001750 0001750 00000003046 11262212046 022106 0 ustar twerner twerner
7
6
4
3
2
this is a test
so is this
this is not a test
some more test
testing, testing, testing
to test or not to test, that is the question
3
4
5
42
73
72653
-1
0
1
42
73
72653
-1
0
1
42.5
73.0
72653.0
-1.5
0.5
1.0
libjibx1.2-java-1.2.3/build/test/simple/Customer4.java 0000644 0001750 0001750 00000003323 10071714444 022340 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
import java.util.ArrayList;
public class Customer4
{
public Name name;
public Object oname;
public String street1;
public String city;
public String state;
public String zip;
public String phone;
public ArrayList referrals;
}
libjibx1.2-java-1.2.3/build/test/simple/mybinding7a.xml 0000644 0001750 0001750 00000001022 10263166470 022537 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding3b.xml 0000644 0001750 0001750 00000001365 10264375570 022204 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/MyClass4Format.java 0000644 0001750 0001750 00000000401 10071714446 023257 0 ustar twerner twerner
package simple;
class MyClass4Format
{
/*package*/ static String yesNoSerializer(boolean flag) {
return flag ? "yes" : "no";
}
/*package*/ static boolean yesNoDeserializer(String text) {
return "yes".equals(text);
}
}
libjibx1.2-java-1.2.3/build/test/simple/mybinding2c.xml 0000644 0001750 0001750 00000004077 11124406456 022547 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple8b.xml 0000644 0001750 0001750 00000000420 10217763160 022051 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98059
libjibx1.2-java-1.2.3/build/test/simple/mybinding3f.xml 0000644 0001750 0001750 00000003363 11124406456 022550 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mybinding2b.xml 0000644 0001750 0001750 00000004135 11124406456 022541 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mytest5a.xml 0000644 0001750 0001750 00000000705 10316003036 022074 0 ustar twerner twerner
1111
22
3333
444
555555
66
libjibx1.2-java-1.2.3/build/test/simple/binding4d.xml 0000644 0001750 0001750 00000001210 10434261270 022162 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mytest4.xml 0000644 0001750 0001750 00000000535 10435141302 021734 0 ustar twerner twerner 42The Answer1.234134
123
456
5
8
a
2004-06-30
abcd
1
2
3
123456789
abc
def
libjibx1.2-java-1.2.3/build/test/simple/binding8b.xml 0000644 0001750 0001750 00000003326 10221061172 022167 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/MyClass5c.java 0000644 0001750 0001750 00000001622 10071714446 022260 0 ustar twerner twerner
package simple;
import java.util.ArrayList;
class MyClass5c extends MyClass5a
{
/*package*/ boolean factory;
private boolean preset;
private boolean postset;
private int value;
private void preset(Object obj) {
if (!(obj instanceof ArrayList)) {
throw new IllegalStateException("factory called with wrong object");
}
preset = true;
value = 1;
}
private void postset(Object obj) {
if (!(obj instanceof ArrayList)) {
throw new IllegalStateException("factory called with wrong object");
}
postset = true;
if (value == 2) {
value = 3;
}
}
private void preget(Object obj) {
if (!(obj instanceof ArrayList)) {
throw new IllegalStateException("factory called with wrong object");
}
value = 2;
}
protected void verify() {
if (!factory || !preset || !postset) {
throw new IllegalStateException
("factory, pre-set, or post-set method not called");
}
}
}
libjibx1.2-java-1.2.3/build/test/simple/simple4e.xml 0000644 0001750 0001750 00000001546 10435066032 022056 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.1234
Mary
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.4321
Larry
Adams
12345 Plunket Lane
Happy
WA
98095
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/mytest4d.xml 0000644 0001750 0001750 00000000540 10435141302 022074 0 ustar twerner twerner 42The Answer1.234134
123
456
50
8
a
2004-06-30
abcd
1
12
03
012345678
abc
def
libjibx1.2-java-1.2.3/build/test/simple/binding2b.xml 0000644 0001750 0001750 00000001433 10434347154 022173 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding4e.xml 0000644 0001750 0001750 00000001203 10435066032 022165 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding0a.xml 0000644 0001750 0001750 00000001251 11475010410 022152 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple1.xml 0000644 0001750 0001750 00000000463 10074705504 021706 0 ustar twerner twerner
Émile
Poincaré
rte st Antoine de Ginestière’
Paris
FR
98059
01 44 27 67 93
libjibx1.2-java-1.2.3/build/test/simple/mybinding2.xml 0000644 0001750 0001750 00000004166 11124406456 022403 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mybinding6a.xml 0000644 0001750 0001750 00000001236 10264375570 022551 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding1a.xml 0000644 0001750 0001750 00000001102 10217763156 022165 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple2.xml 0000644 0001750 0001750 00000000451 10074705504 021704 0 ustar twerner twerner
Émile
Poincaré
rte st Antoine de Ginestière
Paris
FR
98059
01 44 27 67 93
libjibx1.2-java-1.2.3/build/test/simple/simple9.xml 0000644 0001750 0001750 00000000316 10311010000 021661 0 ustar twerner twerner
Smith
12345 Happy Lane
Plunk
WA
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/NameMarshaller.java 0000644 0001750 0001750 00000004553 11043445702 023352 0 ustar twerner twerner /*
Copyright (c) 2005-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
import org.jibx.runtime.IMarshaller;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.MarshallingContext;
public class NameMarshaller implements IMarshaller
{
/* (non-Javadoc)
* @see org.jibx.runtime.IMarshaller#isExtension(java.lang.String)
*/
public boolean isExtension(String mapname) {
return false;
}
/* (non-Javadoc)
* @see org.jibx.runtime.IMarshaller#marshal(java.lang.Object, org.jibx.runtime.IMarshallingContext)
*/
public void marshal(Object obj, IMarshallingContext ictx)
throws JiBXException {
MarshallingContext ctx = (MarshallingContext)ictx;
Name name = (Name)obj;
ctx.startTag(0, "name");
ctx.element(0, "first-name", name.firstName);
ctx.element(0, "last-name", name.lastName);
ctx.endTag(0, "name");
}
} libjibx1.2-java-1.2.3/build/test/simple/Customer10.java 0000644 0001750 0001750 00000000555 11046604540 022417 0 ustar twerner twerner package simple;
public class Customer10 {
public Identity10 identity;
public Identity10 identity1;
public Identity10 identity2;
public Identity10 identity3;
public String street;
public String city;
public String state;
public Integer zip;
public String phone;
public Marker marker;
public static class Marker {}
}
libjibx1.2-java-1.2.3/build/test/simple/binding8c.xml 0000644 0001750 0001750 00000003414 10257173436 022206 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding0d.xml 0000644 0001750 0001750 00000001016 10435066032 022162 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/NameAliasableMarshallerUnmarshaller.java 0000644 0001750 0001750 00000010006 11257242172 027517 0 ustar twerner twerner /*
Copyright (c) 2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
import org.jibx.runtime.IAliasable;
import org.jibx.runtime.IMarshaller;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IUnmarshaller;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.MarshallingContext;
import org.jibx.runtime.impl.UnmarshallingContext;
public class NameAliasableMarshallerUnmarshaller implements IMarshaller,
IUnmarshaller,IAliasable
{
private final String m_uri;
private final int m_index;
private final String m_name;
/**
* Aliased constructor.
*
* @param uri namespace URI for the top-level element
* @param index namespace index corresponding to the defined URI within the
* marshalling context definitions
* @param name local name for the top-level element
*/
public NameAliasableMarshallerUnmarshaller(String uri, int index,
String name) {
m_uri = uri;
m_index = index;
m_name = name;
}
/* (non-Javadoc)
* @see org.jibx.runtime.IMarshaller#isExtension(java.lang.String)
*/
public boolean isExtension(String mapname) {
return false;
}
/* (non-Javadoc)
* @see org.jibx.runtime.IMarshaller#marshal(java.lang.Object, org.jibx.runtime.IMarshallingContext)
*/
public void marshal(Object obj, IMarshallingContext ictx)
throws JiBXException {
MarshallingContext ctx = (MarshallingContext)ictx;
Name name = (Name)obj;
ctx.startTag(m_index, m_name);
ctx.element(m_index, "first-name", name.firstName);
ctx.element(m_index, "last-name", name.lastName);
ctx.endTag(m_index, m_name);
}
/* (non-Javadoc)
* @see org.jibx.runtime.IUnmarshaller#isPresent(org.jibx.runtime.IUnmarshallingContext)
*/
public boolean isPresent(IUnmarshallingContext ctx) throws JiBXException {
return ctx.isAt(m_uri, m_name);
}
/* (non-Javadoc)
* @see org.jibx.runtime.IUnmarshaller#unmarshal(java.lang.Object, org.jibx.runtime.IUnmarshallingContext)
*/
public Object unmarshal(Object obj, IUnmarshallingContext ictx) throws JiBXException {
UnmarshallingContext ctx = (UnmarshallingContext)ictx;
Name name = (Name)obj;
if (name == null) {
name = new Name();
}
ctx.parsePastStartTag(m_uri, m_name);
name.firstName = ctx.parseElementText(m_uri, "first-name");
name.lastName = ctx.parseElementText(m_uri, "last-name");
ctx.parsePastEndTag(m_uri, m_name);
return name;
}
} libjibx1.2-java-1.2.3/build/test/simple/simple5b.xml 0000644 0001750 0001750 00000002617 10316003036 022045 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.1234
A
Mary
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.4321
Mary
Lamb
333 Fleece St.
Highlant
WA
98088
888.555.8321
Larry
Adams
12345 Plunket Lane
Happy
WA
98095
888.555.9999
A
5
libjibx1.2-java-1.2.3/build/test/simple/binding3a.xml 0000644 0001750 0001750 00000001330 10071714446 022166 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple5c.xml 0000644 0001750 0001750 00000003047 10425211274 022052 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.1234
A
Mary
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.4321
Mary
Lamb
333 Fleece St.
Highlant
WA
98088
888.555.8321
Larry
Adams
12345 Plunket Lane
Happy
WA
98095
888.555.9999
A
5
libjibx1.2-java-1.2.3/build/test/simple/binding6c.xml 0000644 0001750 0001750 00000004550 11005500010 022154 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple3c.xml 0000644 0001750 0001750 00000001070 10330637714 022050 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.1234
Mary
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.4321
libjibx1.2-java-1.2.3/build/test/simple/Customer5a.java 0000644 0001750 0001750 00000003057 10071714444 022506 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class Customer5a extends Customer5Base
{
public int sourceCode;
}
libjibx1.2-java-1.2.3/build/test/simple/MyClass1Base.java 0000644 0001750 0001750 00000000120 10541617342 022673 0 ustar twerner twerner
package simple;
class MyClass1Base {
protected MyClass1Base(int any) {}
}
libjibx1.2-java-1.2.3/build/test/simple/mybinding3b.xml 0000644 0001750 0001750 00000003344 11124406456 022543 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/Customers8.java 0000644 0001750 0001750 00000004400 10257173436 022532 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
import java.util.ArrayList;
public class Customers8
{
private ArrayList customers = new SubclassedArrayList();
private int getCount() {
return customers.size();
}
private Object getObject(int index) {
return customers.get(index);
}
private void addObject(Object obj) {
customers.add(obj);
}
private ICustomer8 getCustomer(int index) {
return (ICustomer8)customers.get(index);
}
private void addCustomer(ICustomer8 customer) {
customers.add(customer);
}
private static class SubclassedArrayList extends ArrayList {
public SubclassedArrayList() { super(); }
private void internalAddCustomer(ICustomer8 customer) {
super.add(customer);
}
}
}
libjibx1.2-java-1.2.3/build/test/simple/simple6a.xml 0000644 0001750 0001750 00000001165 10257173436 022062 0 ustar twerner twerner
4
12346
4
83222
2
libjibx1.2-java-1.2.3/build/test/simple/MyClass.java 0000644 0001750 0001750 00000000431 10071714446 022025 0 ustar twerner twerner
package simple;
import java.util.ArrayList;
class MyClass {
private int a;
private String b;
private ArrayList ints;
public int getA() { return a; }
public void setA(int a) { this.a = a; }
public String getB() { return b; }
public void setB(String b) { this.b = b; }
}
libjibx1.2-java-1.2.3/build/test/simple/mytest5b.xml 0000644 0001750 0001750 00000000712 10316003036 022073 0 ustar twerner twerner
1111
22
3333
444
555555
66
libjibx1.2-java-1.2.3/build/test/simple/binding5g.xml 0000644 0001750 0001750 00000005223 10425211274 022175 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple6.xml 0000644 0001750 0001750 00000002136 10071714452 021711 0 ustar twerner twerner
4
12345
12345 Happy Lane
Plunk
3
83838
12345 Happy Lane
Plunk
12346
12345 Plunket Lane
Happy
4
83222
12345 Plunket Lane
Happy
2
libjibx1.2-java-1.2.3/build/test/simple/binding5c.xml 0000644 0001750 0001750 00000005222 10602647376 022205 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mytest6e.xml 0000644 0001750 0001750 00000000370 11037475142 022113 0 ustar twerner twerner
1
2
3
1234567890
this is a test
so is this
this is not a test
libjibx1.2-java-1.2.3/build/test/simple/simple5a.xml 0000644 0001750 0001750 00000002234 10305515602 022044 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.1234
Mary
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.4321
Mary
Lamb
333 Fleece St.
Highlant
WA
98088
888.555.8321
Larry
Adams
12345 Plunket Lane
Happy
WA
98095
888.555.9999
5
libjibx1.2-java-1.2.3/build/test/simple/simple8a.xml 0000644 0001750 0001750 00000000335 10217763160 022055 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98059
libjibx1.2-java-1.2.3/build/test/simple/binding9.xml 0000644 0001750 0001750 00000002572 10311010000 022010 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding7a.xml 0000644 0001750 0001750 00000002132 10756367204 022201 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mybinding3h.xml 0000644 0001750 0001750 00000002764 11124406456 022556 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple4b.xml 0000644 0001750 0001750 00000001107 10221341134 022034 0 ustar twerner twerner
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.1234
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.4321
12345 Plunket Lane
Happy
WA
98095
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/Customer5c.java 0000644 0001750 0001750 00000003056 10071714444 022507 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class Customer5c extends Customer5
{
public short qualityCode;
}
libjibx1.2-java-1.2.3/build/test/simple/Subscriber9.java 0000644 0001750 0001750 00000000147 10311010000 022616 0 ustar twerner twerner package simple;
public class Subscriber9 {
public String name;
public Address9 mailAddress;
}
libjibx1.2-java-1.2.3/build/test/simple/Company10.java 0000644 0001750 0001750 00000000160 10311010000 022164 0 ustar twerner twerner package simple;
public class Company10 extends Identity10 {
public String name;
public String taxId;
}
libjibx1.2-java-1.2.3/build/test/simple/mytest7.xml 0000644 0001750 0001750 00000001076 10263166550 021753 0 ustar twerner twerner
7
6
5
4
3
2
1
this is a test
so is this
this is not a test
some more test
testing, testing, testing
to test or not to test, that is the question
1
2
3
4
5
libjibx1.2-java-1.2.3/build/test/simple/simple7c.xml 0000644 0001750 0001750 00000001007 11153073776 022062 0 ustar twerner twerner
3
12345 Happy Lane
Plunk
12345 Happy Lane
Plunk
12345 Plunket Lane
Happy
libjibx1.2-java-1.2.3/build/test/simple/simple9b.xml 0000644 0001750 0001750 00000000520 10311010000 022020 0 ustar twerner twerner
Smith
12345 Happy Lane
Plunk
WA
54321 Happy Lane
Plunk
WA
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/binding2a.xml 0000644 0001750 0001750 00000002043 10425211274 022161 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding4.xml 0000644 0001750 0001750 00000001201 10071714446 022023 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/Customer9.java 0000644 0001750 0001750 00000001526 11135662742 022355 0 ustar twerner twerner package simple;
public class Customer9 {
public int customerNumber;
public String firstName;
public String lastName;
public Address9 shipAddress;
public Address9 billAddress;
public Address9 fakeAddress;
public String phone;
public Customer9() {
// create fake address to make sure test method being called
Address9 fake = new Address9();
fake.street = "Nowhere";
}
public boolean isShipAddress() {
return shipAddress != null;
}
public boolean isBillAddress() {
return billAddress != null;
}
public boolean isFakeAddress() {
return false;
}
public void setFakeAddress(Address9 address) {}
public Address9 getFakeAddress() {
throw new IllegalStateException("getFakeAddress() method called");
}
}
libjibx1.2-java-1.2.3/build/test/simple/simple4.xml 0000644 0001750 0001750 00000001366 10071714452 021713 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.1234
Mary
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.4321
Larry
Adams
12345 Plunket Lane
Happy
WA
98095
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/Customer6bBase.java 0000644 0001750 0001750 00000003170 10410214130 023257 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public abstract class Customer6bBase
{
public Name name;
public String street1;
public String city;
public String state;
public String zip;
}
libjibx1.2-java-1.2.3/build/test/simple/simple4a.xml 0000644 0001750 0001750 00000001366 10071714452 022054 0 ustar twerner twerner
Smith
John
12345 Happy Lane
Plunk
WA
98059
888.555.1234
Mary
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.4321
Adams
Larry
12345 Plunket Lane
Happy
WA
98095
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/binding5e.xml 0000644 0001750 0001750 00000004673 10330637714 022211 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding0.xml 0000644 0001750 0001750 00000000673 10071714446 022033 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mybinding6.xml 0000644 0001750 0001750 00000000672 10071714452 022403 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple2d.xml 0000644 0001750 0001750 00000001206 10434347154 022052 0 ustar twerner twerner
Poincaré
Anything at all
Émile
with
multiple
children
rte st Antoine de Ginestière
Paris
FR
98059
01 44 27 67 93
libjibx1.2-java-1.2.3/build/test/simple/MyClass5a.java 0000644 0001750 0001750 00000000175 10316003036 022244 0 ustar twerner twerner
package simple;
public class MyClass5a
{
protected int value;
protected int altvalue;
protected void verify() {}
}
libjibx1.2-java-1.2.3/build/test/simple/simple3.xml 0000644 0001750 0001750 00000001073 10071714452 021705 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.1234
Mary
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.4321
N313414
N314566
N418833
libjibx1.2-java-1.2.3/build/test/simple/simple3b.xml 0000644 0001750 0001750 00000001130 10257173436 022050 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.1234
Mary
Smith
12345 Happy Lane
Plunk
WA
888.555.4321
- N313414
- N314566
- N418833
libjibx1.2-java-1.2.3/build/test/simple/Customer8d.java 0000644 0001750 0001750 00000003221 10257173436 022513 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class Customer8d extends Customer8a
{
private Integer getZip() { return new Integer(zip); }
private void setZip(Integer value) { zip = value.intValue(); }
}
libjibx1.2-java-1.2.3/build/test/simple/mybinding3.xml 0000644 0001750 0001750 00000003733 11262212046 022374 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding10.xml 0000644 0001750 0001750 00000002075 11046604540 022106 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple1c.xml 0000644 0001750 0001750 00000000524 10434546306 022052 0 ustar twerner twerner
Sosnoski
14618 NE 80th Pl.
Redmond
WA
98052
425 885 7197
libjibx1.2-java-1.2.3/build/test/simple/binding4c.xml 0000644 0001750 0001750 00000001263 10221341134 022161 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding6b.xml 0000644 0001750 0001750 00000004667 11005500010 022164 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/Person10.java 0000644 0001750 0001750 00000000167 10311010000 022033 0 ustar twerner twerner package simple;
public class Person10 extends Identity10 {
public String firstName;
public String lastName;
}
libjibx1.2-java-1.2.3/build/test/simple/mybinding1.xml 0000644 0001750 0001750 00000002103 11124406456 022367 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple1a.xml 0000644 0001750 0001750 00000000306 10217763160 022044 0 ustar twerner twerner
14618 NE 80th Pl.
Redmond
WA
98052
425 885 7197
libjibx1.2-java-1.2.3/build/test/simple/mybinding4a.xml 0000644 0001750 0001750 00000004554 10305475730 022550 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mytest7b.xml 0000644 0001750 0001750 00000001317 10434546306 022114 0 ustar twerner twerner
7
6
4
3
2
this is a test
so is this
this is not a test
some more test
testing, testing, testing
to test or not to test, that is the question
3
4
5
libjibx1.2-java-1.2.3/build/test/simple/simple10b.xml 0000644 0001750 0001750 00000000257 11046604540 022127 0 ustar twerner twerner
12345 Happy Lane
Plunk
WA
98059
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/binding7.xml 0000644 0001750 0001750 00000002565 11153073776 022052 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/Customer8b.java 0000644 0001750 0001750 00000004253 10221061172 022477 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class Customer8b implements ICustomer8, ICustomer8b
{
public String id;
public Name name;
public String street1;
public String city;
public String state;
public Integer zip;
public String getId() { return id; }
public Name getName() { return name; }
public String getStreet() { return street1; }
public String getCity() { return city; }
public String getState() { return state; }
public void setId(String value) { id = value; }
public void setName(Name name) { this.name = name; }
public void setStreet(String value) { street1 = value; }
public void setCity(String value) { city = value; }
public void setState(String value) { state = value; }
}
libjibx1.2-java-1.2.3/build/test/simple/mytest7a.xml 0000644 0001750 0001750 00000001576 10434347154 022122 0 ustar twerner twerner
xxxx
7
so is this
6
5
4
with
multiple
children
3
2
1
this is a test
so is this
this is not a test
some more test
2
testing, testing, testing
to test or not to test, that is the question
1
2
so is this
3
4
5
libjibx1.2-java-1.2.3/build/test/simple/Address9.java 0000644 0001750 0001750 00000000216 10311010000 022075 0 ustar twerner twerner package simple;
public class Address9 {
public String street;
public String city;
public String state;
public Integer zip;
}
libjibx1.2-java-1.2.3/build/test/simple/mybinding7.xml 0000644 0001750 0001750 00000001121 10263166470 022376 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding4b.xml 0000644 0001750 0001750 00000001304 10221341134 022154 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mybinding4b.xml 0000644 0001750 0001750 00000004700 10330637714 022542 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding6a.xml 0000644 0001750 0001750 00000004106 10264375570 022202 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/ICustomer6.java 0000644 0001750 0001750 00000000061 10337570716 022456 0 ustar twerner twerner package simple;
public interface ICustomer6
{
}
libjibx1.2-java-1.2.3/build/test/simple/simple0c.xml 0000644 0001750 0001750 00000000227 10435066032 022043 0 ustar twerner twerner
12345 Happy Lane
Plunk
WA
98059
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/simple7a.xml 0000644 0001750 0001750 00000000054 10071714452 022050 0 ustar twerner twerner
0
libjibx1.2-java-1.2.3/build/test/simple/mytest3.xml 0000644 0001750 0001750 00000000521 11124406456 021740 0 ustar twerner twerner
42
The Answer
1.234134
true
22
33
1
4
1
2
3
1234567890
libjibx1.2-java-1.2.3/build/test/simple/mybinding6b.xml 0000644 0001750 0001750 00000001232 10264375570 022546 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/Customer5Base.java 0000644 0001750 0001750 00000003204 10071714444 023132 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class Customer5Base
{
public Name name;
public String street1;
public String city;
public String state;
public String zip;
public String phone;
}
libjibx1.2-java-1.2.3/build/test/simple/simple3d.xml 0000644 0001750 0001750 00000000633 10071714452 022052 0 ustar twerner twerner
John
12345 Happy Lane
Plunk
WA
98059
888.555.1234
12345 Happy Lane
Plunk
WA
98059
888.555.4321
N313414
N314566
N418833
libjibx1.2-java-1.2.3/build/test/simple/mytest6a.xml 0000644 0001750 0001750 00000000157 10071714452 022107 0 ustar twerner twerner
1
2
3
1234567890
libjibx1.2-java-1.2.3/build/test/simple/binding5d.xml 0000644 0001750 0001750 00000005075 10330637714 022205 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mytest3b.xml 0000644 0001750 0001750 00000000351 11262224722 022100 0 ustar twerner twerner
true
55
1
2
3
1234567890
libjibx1.2-java-1.2.3/build/test/simple/mybinding.xml 0000644 0001750 0001750 00000000471 10071714452 022312 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/Customer3.java 0000644 0001750 0001750 00000003602 10221341134 022324 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
import java.util.ArrayList;
public class Customer3
{
public Name name = new Name();
public String street1;
public String city;
public String state;
public String zip;
public String phone;
public Customer3 referral;
public Object oreferral;
public ArrayList orderIds;
public static Name nameFactory() {
throw new IllegalStateException("Name factory should not be called");
}
}
libjibx1.2-java-1.2.3/build/test/simple/MyClass4.java 0000644 0001750 0001750 00000004426 10435141302 022106 0 ustar twerner twerner
package simple;
import java.util.Vector;
class MyClass4 {
private int a;
private String b;
private double c;
private Boolean d;
private Integer e;
private Integer f;
private String g;
private boolean h;
private boolean i;
private boolean j;
private byte[] k;
private byte l;
private byte m;
private char n;
private String o;
//#!j2me{
private java.sql.Date p;
//#j2me}
private String q;
private String r;
private String s;
private Vector intsAndStrings;
private boolean testG() {
return g != null;
}
private boolean testJ() {
return j;
}
private String getJ() {
return "";
}
private void setJ(String value) {
j = value != null;
}
private void setO(String value) {
o = value;
}
private boolean testO() {
return o != null && !"".equals(o);
}
private static String serializeInteger(Integer value) {
return value.toString();
}
private static String yesNoSerializer(boolean flag) {
return flag ? "yes" : "no";
}
private static boolean yesNoDeserializer(String text) {
return "yes".equals(text);
}
private void postSet() {
if (q != null && q.length() == 0) {
q = null;
}
if (r != null && r.length() == 0) {
r = null;
}
}
private static class IntWrapper
{
private int ivalue;
}
protected static String serializeNumber(Number num) {
return num.toString();
}
protected static Number deserializeNumber(String value) {
if (value.indexOf('.') >= 0) {
return new Float(value);
} else {
return new Integer(value);
}
}
private static String reverse(String string) {
StringBuffer buff = new StringBuffer(string.length());
for (int i = string.length() - 1; i >= 0 ; i--) {
buff.append(string.charAt(i));
}
return buff.toString();
}
protected static String serializeReverse(Number num) {
return reverse(serializeNumber(num));
}
protected static Number deserializeReverse(String value) {
return deserializeNumber(reverse(value));
}
}
libjibx1.2-java-1.2.3/build/test/simple/mytest4c.xml 0000644 0001750 0001750 00000000636 10305475730 022114 0 ustar twerner twerner 42The Answer1.234134
123
456
this is bold text]]>
d2hhdCAgd2lsbCAgIHByaW50ICAgICBvdXQgICAgICAa
127
<
abcd
first
1
3
1234567890
abc
2
def
libjibx1.2-java-1.2.3/build/test/simple/simple10.xml 0000644 0001750 0001750 00000000404 11046604540 021757 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/MyClass5b.java 0000644 0001750 0001750 00000001004 10071714446 022251 0 ustar twerner twerner
package simple;
class MyClass5b extends MyClass5a
{
/*package*/ boolean factory;
private boolean preset;
private boolean postset;
private int value;
private void preset() {
preset = true;
value = 1;
}
private void postset() {
postset = true;
if (value == 2) {
value = 3;
}
}
private void preget() {
value = 2;
}
protected void verify() {
if (!factory || !preset || !postset) {
throw new IllegalStateException
("factory, pre-set, or post-set method not called");
}
}
}
libjibx1.2-java-1.2.3/build/test/simple/simple10a.xml 0000644 0001750 0001750 00000000412 11046604540 022117 0 ustar twerner twerner
John Smith Enterprises
91-234851
12345 Happy Lane
Plunk
WA
98059
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/mybinding3e.xml 0000644 0001750 0001750 00000003356 11124406456 022551 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/MyClass7.java 0000644 0001750 0001750 00000000375 10524454444 022125 0 ustar twerner twerner
package simple;
import java.util.List;
class MyClass7
{
private List list;
private Object[] array;
private String[] array2;
private int[][] array3;
private long[][] array4;
private double[][] array5;
private List list2;
}
libjibx1.2-java-1.2.3/build/test/simple/simple2c.xml 0000644 0001750 0001750 00000000530 10172154762 022050 0 ustar twerner twerner
Émile
Poincaré
rte st Antoine de Ginestière
Paris
FR
98059
01 44 27 67 93
libjibx1.2-java-1.2.3/build/test/simple/simple9a.xml 0000644 0001750 0001750 00000000205 10311010000 022017 0 ustar twerner twerner
John Smith
12345 Happy Lane
libjibx1.2-java-1.2.3/build/test/simple/NameUnmarshaller.java 0000644 0001750 0001750 00000005110 10316003036 023673 0 ustar twerner twerner /*
Copyright (c) 2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
import org.jibx.runtime.IUnmarshaller;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.UnmarshallingContext;
public class NameUnmarshaller implements IUnmarshaller
{
/* (non-Javadoc)
* @see org.jibx.runtime.IUnmarshaller#isPresent(org.jibx.runtime.IUnmarshallingContext)
*/
public boolean isPresent(IUnmarshallingContext ctx) throws JiBXException {
return ctx.isAt(null, "name");
}
/* (non-Javadoc)
* @see org.jibx.runtime.IUnmarshaller#unmarshal(java.lang.Object, org.jibx.runtime.IUnmarshallingContext)
*/
public Object unmarshal(Object obj, IUnmarshallingContext ictx) throws JiBXException {
UnmarshallingContext ctx = (UnmarshallingContext)ictx;
Name name = (Name)obj;
if (name == null) {
name = new Name();
}
ctx.parsePastStartTag(null, "name");
name.firstName = ctx.parseElementText(null, "first-name");
name.lastName = ctx.parseElementText(null, "last-name");
ctx.parsePastEndTag(null, "name");
return name;
}
} libjibx1.2-java-1.2.3/build/test/simple/mybinding3g.xml 0000644 0001750 0001750 00000002761 11124406456 022552 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple6b.xml 0000644 0001750 0001750 00000001631 10410214130 022033 0 ustar twerner twerner
4
12346
4
83222
2
libjibx1.2-java-1.2.3/build/test/simple/mybinding4.xml 0000644 0001750 0001750 00000004730 10240174212 022370 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple5d.xml 0000644 0001750 0001750 00000002617 10602647376 022072 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.1234
A
Mary
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.4321
Larry
Adams
12345 Plunket Lane
Happy
WA
98095
888.555.9999
A
5
Mary
Lamb
333 Fleece St.
Highlant
WA
98088
888.555.8321
libjibx1.2-java-1.2.3/build/test/simple/mytest6b.xml 0000644 0001750 0001750 00000000325 10071714452 022105 0 ustar twerner twerner
1
2
3
1234567890
this is a test
so is this
this is not a test
libjibx1.2-java-1.2.3/build/test/simple/mytest3c.xml 0000644 0001750 0001750 00000002264 11124406456 022111 0 ustar twerner twerner
The Answer
22
33
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
libjibx1.2-java-1.2.3/build/test/simple/mybinding5b.xml 0000644 0001750 0001750 00000002052 10425211274 022533 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding10a.xml 0000644 0001750 0001750 00000002754 11046604540 022253 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding1.xml 0000644 0001750 0001750 00000000656 10435065660 022036 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding2c.xml 0000644 0001750 0001750 00000001320 10524445116 022164 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple0b.xml 0000644 0001750 0001750 00000000346 10435066032 022044 0 ustar twerner twerner
12345 Happy Lane
Plunk
WA
98059
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/binding9d.xml 0000644 0001750 0001750 00000003507 11135662742 022212 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mytest.xml 0000644 0001750 0001750 00000000231 10071714452 021651 0 ustar twerner twerner
42
The Answer
1
2
3
1234567890
libjibx1.2-java-1.2.3/build/test/simple/mytest2.xml 0000644 0001750 0001750 00000000421 11124406456 021736 0 ustar twerner twerner
12345678
22
33
1
2
3
4567890
libjibx1.2-java-1.2.3/build/test/simple/Customer6aIntermediary.java 0000644 0001750 0001750 00000003107 10410214130 025040 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public abstract class Customer6aIntermediary extends Customer6aBase
{
public String unused;
}
libjibx1.2-java-1.2.3/build/test/simple/mytest4b.xml 0000644 0001750 0001750 00000000605 10222704776 022112 0 ustar twerner twerner 42The Answer1.234134
123
456
this is bold text]]>
d2hhdCAgd2lsbCAgIHByaW50ICAgICBvdXQgICAgICAa
127
<
abcd
1
2
3
1234567890
abc
def
libjibx1.2-java-1.2.3/build/test/simple/mytest4a.xml 0000644 0001750 0001750 00000000465 10222704776 022115 0 ustar twerner twerner 42The Answer1.234134
123
456
d2hhdCB3aWxsIHByaW50IG91dA==
-25
#
1
2
3
1234567890
abc
def
libjibx1.2-java-1.2.3/build/test/simple/simple8d.xml 0000644 0001750 0001750 00000002115 10221061172 022043 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98022
Mary
Smith
12345 Happy Lane
Plunk
WA
98022
Larry
Adams
12345 Plunket Lane
Happy
WA
98095
Gary
Adams
12345 Plunket Lane
Happy
WA
98095
libjibx1.2-java-1.2.3/build/test/simple/Customer5b.java 0000644 0001750 0001750 00000003027 10071714444 022504 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class Customer5b extends Customer5Base
{
}
libjibx1.2-java-1.2.3/build/test/simple/mybinding6e.xml 0000644 0001750 0001750 00000002117 11037475150 022546 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple1b.xml 0000644 0001750 0001750 00000000375 10217763160 022053 0 ustar twerner twerner
Sosnoski
14618 NE 80th Pl.
Redmond
WA
98052
425 885 7197
libjibx1.2-java-1.2.3/build/test/simple/mytest3e.xml 0000644 0001750 0001750 00000000355 11124406456 022112 0 ustar twerner twerner
The Answer
22
33
1
2
3
1234567890
libjibx1.2-java-1.2.3/build/test/simple/mybinding3a.xml 0000644 0001750 0001750 00000004332 11262224722 022535 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple9d.xml 0000644 0001750 0001750 00000000445 10541617520 022061 0 ustar twerner twerner
Smith
54321 Happy Lane
Plunk
WA
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/mybinding3d.xml 0000644 0001750 0001750 00000003624 11124406456 022546 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding3e.xml 0000644 0001750 0001750 00000001665 10330637714 022205 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/ICustomer6a.java 0000644 0001750 0001750 00000000105 10756367204 022617 0 ustar twerner twerner package simple;
public interface ICustomer6a extends ICustomer6
{
}
libjibx1.2-java-1.2.3/build/test/simple/simple.xml 0000644 0001750 0001750 00000000355 10071714452 021624 0 ustar twerner twerner
John
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/mytest2a.xml 0000644 0001750 0001750 00000000174 10337570716 022112 0 ustar twerner twerner 12345678
libjibx1.2-java-1.2.3/build/test/simple/MyClass3.java 0000644 0001750 0001750 00000002033 11124406456 022107 0 ustar twerner twerner
package simple;
import java.text.DecimalFormat;
import java.util.ArrayList;
class MyClass3 {
private int a;
private String b;
private double c;
private boolean d;
private char e;
private DecimalFormat format1;
private DecimalFormat format2;
private int[] ints;
private Integer[] integers;
private long[] longs;
private void addInt(Integer value) {
if (integers == null) {
integers = new Integer[1];
integers[0] = value;
} else {
int length = integers.length;
Integer[] newints = new Integer[length+1];
System.arraycopy(integers, 0, newints, 0, length);
newints[length] = value;
integers = newints;
}
}
private int sizeInts() {
if (integers == null) {
return 0;
} else {
return integers.length;
}
}
private Integer getInt(int index) {
return integers[index];
}
private boolean hasInts() {
return integers != null;
}
}
libjibx1.2-java-1.2.3/build/test/simple/mytest3f.xml 0000644 0001750 0001750 00000000771 11124406456 022115 0 ustar twerner twerner
The Answer
1.234134
42
true
all my content
22
all my content
33
1
all my content
4
1
2
3
1234567890
libjibx1.2-java-1.2.3/build/test/simple/mybinding3c.xml 0000644 0001750 0001750 00000003552 11124406456 022545 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mytest3g.xml 0000644 0001750 0001750 00000001060 11124406456 022106 0 ustar twerner twerner
false
4.88
The Wrong Answer
The Answer
1.234134
true
42
all my content
22
all my content
33
1
all my content
4
1
2
3
1234567890
libjibx1.2-java-1.2.3/build/test/simple/binding7c.xml 0000644 0001750 0001750 00000003251 11153073776 022206 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding1b.xml 0000644 0001750 0001750 00000000676 10434546306 022202 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple4d.xml 0000644 0001750 0001750 00000001734 11010027232 022041 0 ustar twerner twerner
Adam
Smith
John
12345 Happy Lane
Plunk
WA
98059
888.555.1234
Doctor
Mary
Smith
Anne
12345 Happy Lane
Plunk
WA
98059
888.555.4321
Jr.
Adams
Larry
<form>Honorary</form>
<type>Ph.D.</type>
Doctor
12345 Plunket Lane
Happy
WA
98095
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/Customer6a.java 0000644 0001750 0001750 00000003217 10756367204 022515 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class Customer6a extends Customer6aIntermediary
{
public long customerId;
public boolean repeat;
public byte orderCount;
public ICustomer6 innerCustomer;
}
libjibx1.2-java-1.2.3/build/test/simple/mybinding5.xml 0000644 0001750 0001750 00000002052 10425211274 022371 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple0a.xml 0000644 0001750 0001750 00000000353 10240174212 022033 0 ustar twerner twerner
John
12345 Happy Lane
Plunk
WA
98059
888.555.1234
Smith
libjibx1.2-java-1.2.3/build/test/simple/binding5b.xml 0000644 0001750 0001750 00000004065 10305515602 022172 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple7d.xml 0000644 0001750 0001750 00000001076 11153073776 022071 0 ustar twerner twerner
3
12345 Happy Lane
Plunk
abc
12345 Happy Lane
Plunk
12345 Plunket Lane
Happy
abcdef
libjibx1.2-java-1.2.3/build/test/simple/binding6.xml 0000644 0001750 0001750 00000003765 10071714452 022043 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/MyClass5d.java 0000644 0001750 0001750 00000003051 10316003036 022243 0 ustar twerner twerner
package simple;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.ITrackSource;
import org.jibx.runtime.IUnmarshallingContext;
class MyClass5d extends MyClass5a
{
/*package*/ boolean factory;
private boolean preset;
private boolean postset;
private String text1;
private String text2;
private void preset(IUnmarshallingContext ctx) {
if (!(ctx.getStackObject(1) instanceof MyClass5)) {
throw new IllegalStateException("wrong object in stack: " +
ctx.getStackObject(1).getClass().getName());
}
preset = true;
value = 1;
}
private void postset(IUnmarshallingContext ctx) {
if (!(ctx.getStackObject(1) instanceof MyClass5)) {
throw new IllegalStateException("wrong object in stack: " +
ctx.getStackObject(1).getClass().getName());
}
postset = true;
if (value == 2) {
value = 3;
}
}
private void preget(IMarshallingContext ctx) {
if (!(ctx.getStackObject(1) instanceof MyClass5)) {
throw new IllegalStateException("wrong object in stack: " +
ctx.getStackObject(1).getClass().getName());
}
value = 2;
}
protected void verify() {
if (!factory || !preset || !postset) {
throw new IllegalStateException
("factory, pre-set, or post-set method not called");
}
ITrackSource track = (ITrackSource)this;
System.out.println("Verified " + this.getClass().getName() +
" from \"" + track.jibx_getDocumentName() + "\" (" +
track.jibx_getLineNumber() + ":" + track.jibx_getColumnNumber() +
")");
}
}
libjibx1.2-java-1.2.3/build/test/simple/binding8d.xml 0000644 0001750 0001750 00000003765 10257173436 022220 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/Customer1.java 0000644 0001750 0001750 00000003400 10217763160 022332 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class Customer1
{
public String firstName;
public String lastName;
public String street1;
public String city;
public String state;
public String zip;
public String phone;
public boolean hasName() {
return firstName != null || lastName != null;
}
}
libjibx1.2-java-1.2.3/build/test/simple/binding8.xml 0000644 0001750 0001750 00000002443 10222704776 022043 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/Customer6aBase.java 0000644 0001750 0001750 00000003224 10756367204 023306 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public abstract class Customer6aBase implements ICustomer6a
{
private Name name;
private String street1;
private String city;
private String state;
private String zip;
}
libjibx1.2-java-1.2.3/build/test/simple/mytest1.xml 0000644 0001750 0001750 00000000410 11124406456 021733 0 ustar twerner twerner
42
<![CDATAThe Answer]]>
22
33
1
2
3
1234567890
libjibx1.2-java-1.2.3/build/test/simple/simple4c.xml 0000644 0001750 0001750 00000001132 10221341134 022033 0 ustar twerner twerner
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.1234
Smith
12345 Happy Lane
Plunk
WA
98059
888.555.4321
12345 Plunket Lane
Happy
WA
98095
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/binding4a.xml 0000644 0001750 0001750 00000001237 10071714446 022175 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/Customers7.java 0000644 0001750 0001750 00000013670 11322733304 022530 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
import java.util.Iterator;
public class Customers7
{
private DerivedCollection collection = new DerivedCollection();
private void setCustomerCount(int count) {
if (count > 0) {
collection.setCustomerCount(count);
} else {
collection = null;
}
}
private int getCustomerCount() {
if (collection == null) {
return 0;
} else {
return collection.getCustomerCount();
}
}
private void wrappedAddCustomer(Object obj) {
collection.addCustomer((CustomerInterface)obj);
}
private boolean wrappedHasCustomer() {
return collection != null && collection.hasCustomer();
}
private Iterator wrappedGetCustomerIterator() {
return new CustomerIterator(collection);
}
private static class CustomerCollection {
private int fillPosition;
private CustomerInterface[] customers;
protected void setCustomerCount(int count) {
customers = new Customer[count];
fillPosition = 0;
}
protected int getCustomerCount() {
return fillPosition;
}
protected void addCustomer(CustomerInterface obj) {
customers[fillPosition++] = obj;
}
protected boolean hasCustomer() {
return fillPosition > 0;
}
protected CustomerInterface getCustomer(int index) {
return customers[index];
}
protected Iterator getCustomerIterator() {
return new CustomerIterator(this);
}
}
private static class DerivedCollection extends CustomerCollection {
}
private static class CustomerIterator implements Iterator {
private final CustomerCollection collection;
int nextIndex;
private CustomerIterator(CustomerCollection coll) {
collection = coll;
nextIndex = 0;
}
public boolean hasNext() {
return collection != null && nextIndex < collection.fillPosition;
}
public Object next() {
if (nextIndex < collection.fillPosition) {
return collection.getCustomer(nextIndex++);
} else {
return null;
}
}
public void remove() {
throw new UnsupportedOperationException("No remove support");
}
}
public static CustomerInterface createCustomer() {
return new Customer();
}
public interface CustomerInterface
{
public Name getName();
public boolean isName();
public void flagName(boolean flag);
public String getStreet1();
public String getCity();
public String getState();
public String getZip();
public void setName(Name name);
public void setStreet1(String street1);
public void setCity(String city);
public void setState(String state);
public void setZip(String zip);
public boolean isExtra();
public void flagExtra(boolean flag);
public boolean isSkipped();
public void flagSkipped(boolean flag);
}
public interface ExtendedCustomerInterface extends CustomerInterface {}
public static class Customer implements ExtendedCustomerInterface
{
private Name name;
private boolean ifName;
private String street1;
private String city;
private String state;
private String zip;
private boolean extra;
private boolean skipped;
public Name getName() { return name; }
public boolean isName() { return ifName; }
public void flagName(boolean flag) { ifName = flag; }
public String getStreet1() { return street1; }
public String getCity() { return city; }
public String getState() { return state; }
public String getZip() { return zip; }
public void setName(Name name) { this.name = name; }
public void setStreet1(String street1) { this.street1 = street1; }
public void setCity(String city) { this.city = city; }
public void setState(String state) { this.state = state; }
public void setZip(String zip) { this.zip = zip; }
public boolean isExtra() { return extra; }
public void flagExtra(boolean flag) { extra = flag; }
public boolean isSkipped() { return skipped; }
public void flagSkipped(boolean flag) { skipped = flag; }
}
}
libjibx1.2-java-1.2.3/build/test/simple/binding8a.xml 0000644 0001750 0001750 00000003351 10222704776 022203 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/Customer2.java 0000644 0001750 0001750 00000003520 10330637714 022337 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class Customer2
{
public String firstName;
public String lastName;
public Address address;
public String phone;
public boolean hasName() {
return firstName != null || lastName != null;
}
public Address getAddress() {
return address;
}
public void setAddress(Address addr) {
address = addr;
}
}
libjibx1.2-java-1.2.3/build/test/simple/Customer8c.java 0000644 0001750 0001750 00000004253 10221061172 022500 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 simple;
public class Customer8c implements ICustomer8, ICustomer8c
{
public String id;
public Name name;
public String street1;
public String city;
public String state;
public Integer zip;
public String getId() { return id; }
public Name getName() { return name; }
public String getStreet() { return street1; }
public String getCity() { return city; }
public String getState() { return state; }
public void setId(String value) { id = value; }
public void setName(Name name) { this.name = name; }
public void setStreet(String value) { street1 = value; }
public void setCity(String value) { city = value; }
public void setState(String value) { state = value; }
}
libjibx1.2-java-1.2.3/build/test/simple/mybinding2a.xml 0000644 0001750 0001750 00000004221 11124406456 022534 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/MyClass2.java 0000644 0001750 0001750 00000002457 11124406456 022120 0 ustar twerner twerner
package simple;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
class MyClass2 {
private int a;
private String b;
private double c;
private boolean d;
private Object e;
private Integer f;
private Integer g;
private DecimalFormat format1;
private DecimalFormat format2;
private List ints;
private Set orderedStrings;
public int getA() { return a; }
public void setA(String a) { this.a = Integer.parseInt(a); }
public void setA(int a) { this.a = a; }
public String getB() { return b; }
public void setB(String b) { this.b = b; }
public void setB(int b) { this.b = Integer.toString(b); }
public double getC() { return c; }
public void setC(double c) { this.c = c; }
private Object getG() {
return g;
}
private void setG(Object value) {
g = (Integer)value;
}
private List getList() {
return ints;
}
private void setList(ArrayList list) {
ints = list;
}
private static List listFactory() {
return new ArrayList();
}
private static ArrayList arrayListFactory() {
return new ArrayList();
}
private static SortedSet sortedSetFactory() {
return new TreeSet();
}
}
libjibx1.2-java-1.2.3/build/test/simple/binding5.xml 0000644 0001750 0001750 00000004241 10305515602 022024 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/MyClass1.java 0000644 0001750 0001750 00000001022 11124406456 022102 0 ustar twerner twerner
package simple;
import java.text.DecimalFormat;
import java.util.ArrayList;
class MyClass1 extends MyClass1Base {
private int a;
private String b;
private DecimalFormat format1;
private DecimalFormat format2;
private ArrayList ints;
// force generation of default constructor
public MyClass1(int a) {
super(a);
this.a = a;
}
public int getA() { return a; }
public void setA(int a) { this.a = a; }
public String getB() { return b; }
public void setB(String b) { this.b = b; }
}
libjibx1.2-java-1.2.3/build/test/simple/mybinding4c.xml 0000644 0001750 0001750 00000005350 10435141302 022532 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/mybinding6c.xml 0000644 0001750 0001750 00000002022 11037475154 022543 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple2a.xml 0000644 0001750 0001750 00000000752 11140052364 022043 0 ustar twerner twerner ÿþ< ? x m l v e r s i o n = " 1 . 0 " e n c o d i n g = " U T F - 1 6 " ? >
< c u s t o m e r >
< n a m e >
< f i r s t - n a m e > J o h n < / f i r s t - n a m e >
< / n a m e >
< s t r e e t 1 > 1 2 3 4 5 H a p p y L a n e < / s t r e e t 1 >
< c i t y > P l u n k < / c i t y >
< s t a t e > W A < / s t a t e >
< z i p > 9 8 0 5 9 < / z i p >
< p h o n e > 8 8 8 . 5 5 5 . 1 2 3 4 < / p h o n e >
< / c u s t o m e r >
libjibx1.2-java-1.2.3/build/test/simple/simple9c.xml 0000644 0001750 0001750 00000000367 10311010000 022032 0 ustar twerner twerner
Smith
54321 Happy Lane
Plunk
WA
888.555.1234
libjibx1.2-java-1.2.3/build/test/simple/mybinding7b.xml 0000644 0001750 0001750 00000001354 10330637714 022547 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/binding5f.xml 0000644 0001750 0001750 00000004162 11257242172 022202 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/test/simple/simple9e.xml 0000644 0001750 0001750 00000000634 10541617520 022062 0 ustar twerner twerner
Smith
12345 Happy Lane
Plunk
WA
54321 Happy Lane
Plunk
WA
888.555.1234
libjibx1.2-java-1.2.3/build/test/multiple/ 0000755 0001750 0001750 00000000000 11526304016 020145 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/test/multiple/CarrierBean.java 0000644 0001750 0001750 00000004733 10071714436 023201 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Sosnoski Software Solutions, Inc.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 multiple;
/**
* Carrier information.
*
* @author Dennis M. Sosnoski
* @version 0.8
*/
public class CarrierBean
{
private String m_ident;
private String m_name;
private String m_url;
private int m_rating;
public CarrierBean() {}
public void setIdent(String ident) {
m_ident = ident;
}
public String getIdent() {
return m_ident;
}
public void setName(String name) {
m_name = name;
}
public String getName() {
return m_name;
}
public void setURL(String url) {
m_url = url;
}
public String getURL() {
return m_url;
}
public void setRating(int rating) {
m_rating = rating;
}
public int getRating() {
return m_rating;
}
public boolean equals(Object obj) {
if (obj instanceof CarrierBean) {
CarrierBean compare = (CarrierBean)obj;
return Utils.equalStrings(m_ident, compare.m_ident) &&
Utils.equalStrings(m_name, compare.m_name) &&
Utils.equalStrings(m_url, compare.m_url) &&
m_rating == compare.m_rating;
} else {
return false;
}
}
}
libjibx1.2-java-1.2.3/build/test/multiple/RouteBean.java 0000644 0001750 0001750 00000004627 10071714436 022712 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Sosnoski Software Solutions, Inc.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 multiple;
import java.util.ArrayList;
/**
* Route information.
*
* @author Dennis M. Sosnoski
* @version 0.8
*/
public class RouteBean
{
private AirportBean m_from;
private AirportBean m_to;
private ArrayList m_flights;
public RouteBean() {
m_flights = new ArrayList();
}
public void setFrom(AirportBean from) {
m_from = from;
}
public AirportBean getFrom() {
return m_from;
}
public void setTo(AirportBean to) {
m_to = to;
}
public AirportBean getTo() {
return m_to;
}
public ArrayList getFlights() {
return m_flights;
}
public void addFlight(FlightBean flight) {
m_flights.add(flight);
}
public boolean equals(Object obj) {
if (obj instanceof RouteBean) {
RouteBean compare = (RouteBean)obj;
return Utils.equalAirports(m_to, compare.m_to) &&
Utils.equalAirports(m_from, compare.m_from) &&
Utils.equalLists(m_flights, compare.m_flights);
} else {
return false;
}
}
}
libjibx1.2-java-1.2.3/build/test/multiple/FlightTimesBean.java 0000644 0001750 0001750 00000004244 10071714436 024026 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Sosnoski Software Solutions, Inc.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 multiple;
/**
* Flight time information.
*
* @author Dennis M. Sosnoski
* @version 0.8
*/
public class FlightTimesBean
{
private int m_departure;
private int m_arrival;
public FlightTimesBean() {}
public void setDeparture(int minute) {
m_departure = minute;
}
public int getDeparture() {
return m_departure;
}
public void setArrival(int minute) {
m_arrival = minute;
}
public int getArrival() {
return m_arrival;
}
public boolean equals(Object obj) {
if (obj instanceof FlightTimesBean) {
FlightTimesBean compare = (FlightTimesBean)obj;
return m_departure == compare.m_departure &&
m_arrival == compare.m_arrival;
} else {
return false;
}
}
}
libjibx1.2-java-1.2.3/build/test/multiple/SplitFlightBean.java 0000644 0001750 0001750 00000003742 10071714436 024042 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Sosnoski Software Solutions, Inc.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 multiple;
/**
* Flight information in child objects.
*
* @author Dennis M. Sosnoski
* @version 0.8
*/
public class SplitFlightBean
{
private FlightIdentityBean m_identity;
private FlightTimesBean m_times;
public SplitFlightBean() {}
public boolean equals(Object obj) {
if (obj instanceof SplitFlightBean) {
SplitFlightBean compare = (SplitFlightBean)obj;
return m_identity.equals(compare.m_identity) &&
m_times.equals(compare.m_times);
} else {
return false;
}
}
}
libjibx1.2-java-1.2.3/build/test/multiple/Utils.java 0000644 0001750 0001750 00000006743 10071714436 022127 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Sosnoski Software Solutions, Inc.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 multiple;
import java.util.Date;
import java.util.List;
/**
* Static utility class providing comparison methods.
*
* @author Dennis M. Sosnoski
* @version 0.8
*/
public abstract class Utils
{
public static boolean equalStrings(String a, String b) {
return (a == null && b == null) || a.equals(b);
}
public static boolean equalLists(List a, List b) {
return (a == null && b == null) || a.equals(b);
}
public static boolean equalAirports(AirportBean a, AirportBean b) {
return (a == null && b == null) || (a != null && a.equals(b));
}
public static boolean equalCarriers(CarrierBean a, CarrierBean b) {
return (a == null && b == null) || (a != null && a.equals(b));
}
public static boolean equalDates(Date a, Date b) {
return (a == null && b == null) || (a != null && a.equals(b));
}
public static int timeToMinute(String time) {
// find split between hour and minute
int mark = time.indexOf(':');
if (mark > 0) {
// convert hour to adjusted range (0-11)
int hour = Integer.parseInt(time.substring(0, mark));
if (hour == 12) {
hour = 0;
}
// find minute value
String mins = time.substring(mark+1, time.length()-1);
int minute = Integer.parseInt(mins);
// check am/pm flag
char last = time.charAt(time.length()-1);
boolean pm = Character.toLowerCase(last) == 'p';
// return minute number of flight time
return ((pm ? 12 : 0) + hour)*60 + minute;
} else {
throw new IllegalArgumentException("Not a valid time: " + time);
}
}
public static String minuteToTime(int minute) {
// find hour in quirky am/pm form
int hour = minute / 60;
boolean pm = false;
if (hour >= 12) {
hour -= 12;
pm = true;
}
if (hour == 0) {
hour = 12;
}
// convert minute value to double-digit text
minute %= 60;
String mtext = Integer.toString(minute);
if (mtext.length() == 1) {
mtext = '0' + mtext;
}
// return complete time text
return Integer.toString(hour) + ':' + mtext + (pm ? 'p' : 'a');
}
}
libjibx1.2-java-1.2.3/build/test/multiple/TimeTableBean.java 0000644 0001750 0001750 00000005066 10071714436 023460 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Sosnoski Software Solutions, Inc.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 multiple;
import java.util.ArrayList;
/**
* Flight timetable information.
*
* @author Dennis M. Sosnoski
* @version 0.8
*/
public class TimeTableBean
{
private ArrayList m_carriers;
private ArrayList m_airports;
private ArrayList m_routes;
public TimeTableBean() {
m_carriers = new ArrayList();
m_airports = new ArrayList();
m_routes = new ArrayList();
}
public ArrayList getCarriers() {
return m_carriers;
}
public void addCarrier(CarrierBean carrier) {
m_carriers.add(carrier);
}
public ArrayList getAirports() {
return m_airports;
}
public void addAirport(AirportBean airport) {
m_airports.add(airport);
}
public ArrayList getRoutes() {
return m_routes;
}
public void addRoute(RouteBean route) {
m_routes.add(route);
}
public boolean equals(Object obj) {
if (obj instanceof TimeTableBean) {
TimeTableBean compare = (TimeTableBean)obj;
return Utils.equalLists(m_routes, compare.m_routes) &&
Utils.equalLists(m_airports, compare.m_airports) &&
Utils.equalLists(m_carriers, compare.m_carriers);
} else {
return false;
}
}
}
libjibx1.2-java-1.2.3/build/test/multiple/SplitRouteBean.java 0000644 0001750 0001750 00000004713 10071714436 023722 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Sosnoski Software Solutions, Inc.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 multiple;
import java.util.ArrayList;
/**
* Route bean with split route information.
*
* @author Dennis M. Sosnoski
* @version 0.8
*/
public class SplitRouteBean
{
private AirportBean m_from;
private AirportBean m_to;
private ArrayList m_flights;
public SplitRouteBean() {
m_flights = new ArrayList();
}
public void setFrom(AirportBean from) {
m_from = from;
}
public AirportBean getFrom() {
return m_from;
}
public void setTo(AirportBean to) {
m_to = to;
}
public AirportBean getTo() {
return m_to;
}
public ArrayList getFlights() {
return m_flights;
}
public void addFlight(SplitFlightBean flight) {
m_flights.add(flight);
}
public boolean equals(Object obj) {
if (obj instanceof SplitRouteBean) {
SplitRouteBean compare = (SplitRouteBean)obj;
return Utils.equalAirports(m_to, compare.m_to) &&
Utils.equalAirports(m_from, compare.m_from) &&
Utils.equalLists(m_flights, compare.m_flights);
} else {
return false;
}
}
}
libjibx1.2-java-1.2.3/build/test/multiple/AirportBean.java 0000644 0001750 0001750 00000004537 10071714436 023234 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Sosnoski Software Solutions, Inc.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 multiple;
/**
* Airport information.
*
* @author Dennis M. Sosnoski
* @version 0.8
*/
public class AirportBean
{ private String m_ident;
private String m_name;
private String m_location;
public AirportBean() {}
public void setIdent(String ident) {
m_ident = ident;
}
public String getIdent() {
return m_ident;
}
public void setName(String name) {
m_name = name;
}
public String getName() {
return m_name;
}
public void setLocation(String location) {
m_location = location;
}
public String getLocation() {
return m_location;
}
public boolean equals(Object obj) {
if (obj instanceof AirportBean) {
AirportBean compare = (AirportBean)obj;
return Utils.equalStrings(m_ident, compare.m_ident) &&
Utils.equalStrings(m_name, compare.m_name) &&
Utils.equalStrings(m_location, compare.m_location);
} else {
return false;
}
}
}
libjibx1.2-java-1.2.3/build/test/multiple/FlightIdentityBean.java 0000644 0001750 0001750 00000006071 10221061036 024522 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Sosnoski Software Solutions, Inc.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 multiple;
import java.util.Date;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.Utility;
/**
* Flight identity information.
*
* @author Dennis M. Sosnoski
* @version 0.8
*/
public class FlightIdentityBean
{
private static Date s_defaultStartDate;
private static Date s_defaultEndDate;
{
try {
s_defaultStartDate = Utility.deserializeDate("2003-01-01");
s_defaultEndDate = Utility.deserializeDate("2005-12-31");
} catch (JiBXException ex) {
s_defaultStartDate = s_defaultEndDate = new Date();
}
}
private CarrierBean m_carrier;
private String m_id;
private int m_number;
private double m_onTime;
private Date m_startDate;
private Date m_endDate;
public FlightIdentityBean() {}
public void setCarrier(CarrierBean carrier) {
m_carrier = carrier;
}
public CarrierBean getCarrier() {
return m_carrier;
}
public void setNumber(int number) {
m_number = number;
}
public int getNumber() {
return m_number;
}
public void preset() {
m_onTime = 0.5D;
}
public void postComplete() {
if (m_startDate == null) {
m_startDate = s_defaultStartDate;
}
if (m_endDate == null) {
m_endDate = s_defaultEndDate;
}
}
public void preget() {
m_onTime *= 1.5D;
}
public boolean equals(Object obj) {
if (obj instanceof FlightBean) {
FlightIdentityBean compare = (FlightIdentityBean)obj;
return Utils.equalCarriers(m_carrier, compare.m_carrier) &&
m_number == compare.m_number &&
Utils.equalDates(m_startDate, compare.m_startDate) &&
Utils.equalDates(m_endDate, compare.m_endDate);
} else {
return false;
}
}
}
libjibx1.2-java-1.2.3/build/test/multiple/FlightBean.java 0000644 0001750 0001750 00000005530 10071714436 023023 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Sosnoski Software Solutions, Inc.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 multiple;
/**
* Flight information.
*
* @author Dennis M. Sosnoski
* @version 0.8
*/
public class FlightBean
{
private CarrierBean m_carrier;
private int m_number;
private int m_departure;
private int m_arrival;
public FlightBean() {}
public void setCarrier(CarrierBean carrier) {
m_carrier = carrier;
}
public CarrierBean getCarrier() {
return m_carrier;
}
public void setNumber(int number) {
m_number = number;
}
public int getNumber() {
return m_number;
}
public void setDeparture(int minute) {
m_departure = minute;
}
public int getDeparture() {
return m_departure;
}
public void setDepartureTime(String time) {
m_departure = Utils.timeToMinute(time);
}
public String getDepartureTime() {
return Utils.minuteToTime(m_departure);
}
public void setArrival(int minute) {
m_arrival = minute;
}
public int getArrival() {
return m_arrival;
}
public void setArrivalTime(String time) {
m_arrival = Utils.timeToMinute(time);
}
public String getArrivalTime() {
return Utils.minuteToTime(m_arrival);
}
public boolean equals(Object obj) {
if (obj instanceof FlightBean) {
FlightBean compare = (FlightBean)obj;
return Utils.equalCarriers(m_carrier, compare.m_carrier) &&
m_number == compare.m_number &&
m_departure == compare.m_departure &&
m_arrival == compare.m_arrival;
} else {
return false;
}
}
}
libjibx1.2-java-1.2.3/build/test/multiple/SplitTableBean.java 0000644 0001750 0001750 00000005420 10221061040 023626 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Sosnoski Software Solutions, Inc.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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 multiple;
import java.util.ArrayList;
/**
* Flight timetable information with split flights.
*
* @author Dennis M. Sosnoski
* @version 0.8
*/
public class SplitTableBean
{
private ArrayList m_carriers;
private ArrayList m_airports;
private ArrayList m_flights; // used only where flights are predefined in
// collection and then referenced
private ArrayList m_routes;
public SplitTableBean() {
m_carriers = new ArrayList();
m_airports = new ArrayList();
m_flights = new ArrayList();
m_routes = new ArrayList();
}
public ArrayList getCarriers() {
return m_carriers;
}
public void addCarrier(CarrierBean carrier) {
m_carriers.add(carrier);
}
public ArrayList getAirports() {
return m_airports;
}
public void addAirport(AirportBean airport) {
m_airports.add(airport);
}
public ArrayList getRoutes() {
return m_routes;
}
public void addRoute(SplitRouteBean route) {
m_routes.add(route);
}
public boolean equals(Object obj) {
if (obj instanceof SplitTableBean) {
SplitTableBean compare = (SplitTableBean)obj;
return Utils.equalLists(m_routes, compare.m_routes) &&
Utils.equalLists(m_airports, compare.m_airports) &&
Utils.equalLists(m_carriers, compare.m_carriers);
} else {
return false;
}
}
}
libjibx1.2-java-1.2.3/build/build-binding.xml 0000644 0001750 0001750 00000003370 11175704456 020603 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/jenable/ 0000755 0001750 0001750 00000000000 11300355250 016727 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/jenable/JEnable.java 0000644 0001750 0001750 00000104623 10541603272 021106 0 ustar twerner twerner /*
* Copyright (c) 2000-2001 Sosnoski Software Solutions, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
import java.io.*;
import java.util.*;
/**
* Source configuration processor program. This program processes a set of Java
* source files (or standard input to standard output, if no source files are
* specified), scanning for configuration control lines. A control line is a
* line that starts with "//#token*" (valid only as the first line of a
* file), "//#token{" (beginning an option block), "//#}token{" (inverting an
* option block), or "//#token} (closing an option block). The first two formats
* also allow a '!' immediately before the token in order to invert the token
* state.
*
* The token strings to be processed are specified on the command line as
* either enabled or disabled. See the program documentation for more details
* of the command line options and usage.
*
* Nested option blocks are allowed, but overlapping option blocks are an
* error. In order to ensure proper processing of nested option blocks, the
* user should generally specify every token used for the nested blocks
* as either enabled or disabled if any of them are either enabled or
* disabled. It is an error if an indeterminant beginning of block token (one
* with a token which is not on either list) is immediately contained within
* a block with an enabled token. In other words, the case:
*
* //#a{
* //#b{
* //#c{
* //#c}
* //#b}
* //#a}
*
* gives an error if "a" is on the enabled list and "b" is not on either list,
* or if "a" is not on the disabled list, "b" is on the enabled list, and "c"
* is not on either list.
*
* @author Dennis M. Sosnoski
* @version 0.8
*/
public class JEnable
{
/** Lead text for option token. */
protected static final String OPTION_LEAD = "//#";
/** Length of lead text for option token. */
protected static final int LEAD_LENGTH = OPTION_LEAD.length();
/** Size of buffer used to copy file. */
protected static final int COPY_BUFFER_SIZE = 4096;
/** Return code for not an option line. */
protected static final int NOT_OPTION = 0;
/** Return code for file option line. */
protected static final int FILE_OPTION = 1;
/** Return code for block start option line. */
protected static final int BLOCK_START_OPTION = 2;
/** Return code for block else option line. */
protected static final int BLOCK_ELSE_OPTION = 3;
/** Return code for block end option line. */
protected static final int BLOCK_END_OPTION = 4;
/** Return code for block comment option line. */
protected static final int BLOCK_COMMENT_OPTION = 5;
/** Error text for file option not on first line. */
protected static final String FILE_OPTION_ERR =
"file option token must be first line of file";
/** Error text for token nested within block for same token. */
protected static final String NESTED_SAME_ERR =
"block option start cannot be nested within block with same token";
/** Error text for indeterminant token nested in enabled block. */
protected static final String INDETERM_ERR =
"block option token within enabled block must be enabled or disabled";
/** Error text for block end token not matching block start token. */
protected static final String UNBALANCED_ERR =
"block option end without matching start";
/** Error text for block else token not matching block start token. */
protected static final String BADELSE_ERR =
"block option else without matching start";
/** Error text for end of file with open block. */
protected static final String UNCLOSED_ERR =
"end of file with open block";
/** Error text for unknown option token type. */
protected static final String UNKNOWN_OPTION_ERR =
"unknown option line type";
/** Error text for file option line with unknown file extension. */
protected static final String EXTENSION_ERR =
"unknown file option line extension";
/** Error text for unable to rename file to backup directory. */
protected static final String BACKUP_DIR_ERR =
"unable to create backup directory";
/** Error text for unable to delete old backup file. */
protected static final String OLD_BACKUP_ERR =
"unable to delete old backup file";
/** Error text for unable to rename file within directory. */
protected static final String BACKUP_FILE_ERR =
"unable to rename file for backup";
/** Error text for unable to delete original file. */
protected static final String DELETE_ERR =
"unable to delete input file";
/** Error text for unable to rename original file. */
protected static final String RENAME_ERR =
"unable to rename source file";
/** Error text for unable to rename temp file. */
protected static final String TEMP_RENAME_ERR =
"unable to rename temp file";
/** Error text for unable to delete temporary file. */
protected static final String TEMP_DELETE_ERR =
"unable to delete temporary output file";
/** Error text for unable to change file modify timestamp. */
protected static final String STAMP_ERR =
"unable to change file modify timestamp";
/** Error text for token in both sets. */
protected static final String DUAL_USE_ERR =
"Same token cannot be both enabled and disabled";
/** Preserve timestamp on modified files flag. */
protected boolean m_keepStamp;
/** Mark backup file with tilde flag. */
protected boolean m_markBackup;
/** List modified files flag. */
protected boolean m_listModified;
/** List all files processed flag. */
protected boolean m_listProcessed;
/** List file summary by path flag. */
protected boolean m_listSummary;
/** Backup root path (null if not backing up). */
protected File m_backupDir;
/** Map for enabled tokens (values same as keys). */
protected Hashtable m_enabledTokens;
/** Map for disabled tokens (values same as keys). */
protected Hashtable m_disabledTokens;
/** Number of files matched. */
protected int m_matchedCount;
/** Number of files modified. */
protected int m_modifiedCount;
/** Current option token, set by check method. */
private String m_token;
/** Inverted token flag, set by check method. */
private boolean m_invert;
/** Offset past end of token in line, set by check method. */
private int m_endOffset;
/**
* Constructor.
*
* @param keep preserve timestamp on modified files flag
* @param mark mark backup files with tilde flag
* @param mods list modified files flag
* @param quiet do not list file summaries by path flag
* @param verbose list all files processed flag
* @param backup root back for backup directory tree (null if
* no backups)
* @param enabled map of enabled tokens
* @param disabled map of disabled tokens
*/
protected JEnable(boolean keep, boolean mark, boolean mods, boolean quiet,
boolean verbose, File backup, Hashtable enabled, Hashtable disabled) {
m_keepStamp = keep;
m_markBackup = mark;
m_listModified = mods;
m_listProcessed = verbose;
m_listSummary = !quiet;
m_backupDir = backup;
m_enabledTokens = enabled;
m_disabledTokens = disabled;
}
/**
* Checks for valid first character of token. The first character must be
* an alpha or underscore.
*
* @param chr character to be validated
* @return true if valid first character, false
* if not
*/
protected static boolean isTokenLeadChar(char chr) {
return (chr >= 'a' && chr <= 'z') || (chr >= 'A' && chr <= 'Z') ||
chr == '_';
}
/**
* Checks for valid body character of token. All body characters must be
* an alpha, digits, or underscore.
*
* @param chr character to be validated
* @return true if valid body character, false
* if not
*/
protected static boolean isTokenBodyChar(char chr) {
return (chr >= 'a' && chr <= 'z') || (chr >= 'A' && chr <= 'Z') ||
chr == '_' || (chr >= '0' && chr <= '9');
}
/**
* Convenience method for generating an error report exception.
*
* @param lnum line number within file
* @param line source line to check for option
* @param msg error message text
* @throws IOException wrapping the error information
*/
protected void throwError(int lnum, String line, String msg)
throws IOException {
throw new IOException("Error on input line " + lnum + ", " +
msg + ":\n" + line);
}
/**
* Check if line is an option. Returns a code for the option line type
* (or "not an option line"), with the actual token from the line stored
* in the instance variable. Ugly technique, but the only easy way to
* return multiple results without using another class.
*
* @param lnum line number within file (used for error reporting)
* @param line source line to check for option
* @return return code for option line type
* @throws IOException on option line error
*/
protected int checkOptionLine(int lnum, String line) throws IOException {
// check if line is a candidate for option token
int type = NOT_OPTION;
m_token = null;
m_invert = false;
m_endOffset = 0;
if (line.length() > LEAD_LENGTH && line.startsWith(OPTION_LEAD)) {
// check for special leading character before token
int offset = LEAD_LENGTH;
char lead = line.charAt(offset);
if (lead == '!' || lead == '}') {
offset++;
} else {
lead = 0;
}
// make sure a valid token start character follows
int start = offset;
if (isTokenLeadChar(line.charAt(start))) {
// parse the token characters
int scan = LEAD_LENGTH+1;
while (scan < line.length()) {
char chr = line.charAt(scan++);
if (!isTokenBodyChar(chr)) {
// token found, classify and set type
m_token = line.substring(start, scan-1);
m_endOffset = scan;
switch (chr) {
case '*':
// file option, inverted token is only variation
type = FILE_OPTION;
if (lead == '!') {
m_invert = true;
} else if (lead != 0) {
throwError(lnum, line, UNKNOWN_OPTION_ERR);
}
break;
case '{':
// block start option, check variations
if (lead == '}') {
type = BLOCK_ELSE_OPTION;
} else {
if (lead == '!') {
m_invert = true;
}
type = BLOCK_START_OPTION;
}
break;
case '}':
// block end option, no variations allowed
type = BLOCK_END_OPTION;
if (lead != 0) {
throwError(lnum, line, UNKNOWN_OPTION_ERR);
}
break;
case ':':
// block comment option, no variations allowed
type = BLOCK_COMMENT_OPTION;
if (lead != 0) {
throwError(lnum, line, UNKNOWN_OPTION_ERR);
}
break;
default:
// no idea what this is supposed to be
throwError(lnum, line, UNKNOWN_OPTION_ERR);
break;
}
break;
}
}
}
}
return type;
}
/**
* Processes source options for a text stream. If an error occurs in
* processing, this generates an IOException with the error
* information (including input line number).
*
* @param in input reader for source data
* @param lead first line of file (previously read for checking file enable
* or disable)
* @param out output writer for modified source data
* @return true if source modified, false if not
*/
protected boolean processStream(BufferedReader in, String lead,
BufferedWriter out) throws IOException {
// initialize state information
Stack enables = new Stack();
Stack nests = new Stack();
String disable = null;
boolean changed = false;
// basic file line copy loop
String line = lead;
int lnum = 1;
while (line != null) {
// process based on option type
boolean option = true;
int type = checkOptionLine(lnum, line);
switch (type) {
case NOT_OPTION:
option = false;
break;
case FILE_OPTION:
// file option processed outside, but must be first line
if (lnum > 1) {
throwError(lnum, line, FILE_OPTION_ERR);
}
break;
case BLOCK_START_OPTION:
// option block start token, must not be duplicated
if (nests.indexOf(m_token) >= 0) {
throwError(lnum, line, NESTED_SAME_ERR);
} else {
// push to nesting stack and check if we're handling
nests.push(m_token);
if (disable == null) {
// see if we know about this token
boolean on = m_enabledTokens.containsKey(m_token);
boolean off = m_disabledTokens.containsKey(m_token);
// swap flags if inverted token
if (m_invert) {
boolean hold = on;
on = off;
off = hold;
}
// handle start of block
if (off) {
// set disabling option
disable = m_token;
} else if (on) {
// stack enabled option
enables.push(m_token);
} else if (!enables.empty()) {
// error if unknown inside enable
throwError(lnum, line, INDETERM_ERR);
}
}
}
break;
case BLOCK_ELSE_OPTION:
// option block else, must match top of nesting stack
if (nests.empty() || !nests.peek().equals(m_token)) {
throwError(lnum, line, BADELSE_ERR);
} else {
// reverse current state, if known
if (disable == null) {
// enabled state, check if top of stack
if (!enables.empty()) {
if (enables.peek().equals(m_token)) {
// flip to disable state
enables.pop();
disable = m_token;
}
}
} else if (disable.equals(m_token)) {
// flip to enable state
disable = null;
enables.push(m_token);
}
}
break;
case BLOCK_END_OPTION:
// option block end, must match top of nesting stack
if (nests.empty() || !nests.peek().equals(m_token)) {
throwError(lnum, line, UNBALANCED_ERR);
} else {
// remove from nesting stack and check state
nests.pop();
if (disable == null) {
// enabled state, check if top of stack
if (!enables.empty()) {
if (enables.peek().equals(m_token)) {
enables.pop();
}
}
} else if (disable.equals(m_token)) {
disable = null;
}
}
break;
case BLOCK_COMMENT_OPTION:
// disabled line option, check if clearing
if ((disable != null && !disable.equals(m_token)) ||
(disable == null && enables.contains(m_token))) {
// clear disabled line option
line = line.substring(m_endOffset);
option = false;
changed = true;
}
break;
default:
throwError(lnum, line, UNKNOWN_OPTION_ERR);
}
// check for disabling lines
if (!option && disable != null) {
// change line to disabled state
line = OPTION_LEAD + disable + ':' + line;
changed = true;
}
// write (possibly modified) line to output
out.write(line);
out.newLine();
// read next line of input
line = in.readLine();
lnum++;
}
// check for valid end state
if (nests.size() > 0) {
throwError(lnum, (String)nests.pop(), UNCLOSED_ERR);
}
out.flush();
return changed;
}
/**
* Processes source options for a file. Starts by checking the first line
* of the file for a file option and processing that. If, after processing
* the file option, the file has a ".java" extension, it is processed for
* other option lines.
*
* This saves the output to a temporary file, then if processing is
* completed successfully first renames or moves the original file (if
* backup has been requested), or deletes it (if backup not requested),
* and then renames the temporary file to the original file name.
*
* Processing errors are printed to System.err, and any
* results are discarded without being saved.
*
* @param file source file to be processed
* @return true if source modified, false if not
*/
protected boolean processFile(File file) {
File temp = null;
try {
// set up basic information
String name = file.getName();
String dir = file.getParent();
int split = name.lastIndexOf('.');
String ext = (split >= 0) ? name.substring(split+1) : "";
String toext = ext;
long stamp = m_keepStamp ? file.lastModified() : 0;
File target = file;
// check first line for file option
BufferedReader in = new BufferedReader(new FileReader(file));
String line = in.readLine();
int type = checkOptionLine(1, line);
if (type == FILE_OPTION) {
// make sure we have one of the extensions we know about
if (ext.equals("java") || ext.equals("javx")) {
// set "to" extension based on option setting
if (m_enabledTokens.contains(m_token)) {
toext = m_invert ? "javx" : "java";
} else if (m_disabledTokens.contains(m_token)) {
toext = m_invert ? "java" : "javx";
}
// generate new target file name if different extension
if (!toext.equals(ext)) {
split = name.indexOf('.');
name = name.substring(0, split) + '.' + toext;
target = new File(dir, name);
}
} else {
throw new IOException(EXTENSION_ERR);
}
}
// check if extension valid for processing
boolean changed = false;
if (!toext.equals("javx")) {
// set up output to temporary file in same directory
temp = File.createTempFile("sop", null, file.getParentFile());
BufferedWriter out = new BufferedWriter(new FileWriter(temp));
// process the file for changes
changed = processStream(in, line, out);
in.close();
out.close();
if (changed) {
// handle backup of original file
if (m_backupDir != null) {
// construct path within backup directory
String extra = file.getCanonicalPath();
int mark = extra.indexOf(File.separatorChar);
if (mark >= 0) {
extra = extra.substring(mark+1);
}
File backup = new File(m_backupDir, extra);
// copy file to backup directory
File backdir = backup.getParentFile();
if (!backdir.exists() && !backdir.mkdirs()) {
throw new IOException(BACKUP_DIR_ERR + '\n' +
backdir.getPath());
}
if (backup.exists()) {
if (!backup.delete()) {
throw new IOException(OLD_BACKUP_ERR);
}
}
byte[] buff = new byte[COPY_BUFFER_SIZE];
InputStream is = new FileInputStream(file);
OutputStream os = new FileOutputStream(backup);
int bytes;
while ((bytes = is.read(buff)) >= 0) {
os.write(buff, 0, bytes);
}
is.close();
os.close();
backup.setLastModified(file.lastModified());
}
if (m_markBackup) {
// suffix file name with tilde
File backup = new File(dir, name+'~');
if (backup.exists()) {
if (!backup.delete()) {
throw new IOException(OLD_BACKUP_ERR);
}
}
if (!file.renameTo(backup)) {
throw new IOException(BACKUP_FILE_ERR);
}
} else {
// just delete the original file
if (!file.delete()) {
throw new IOException(DELETE_ERR);
}
}
// rename temp to target name
if (temp.renameTo(target)) {
if (m_keepStamp && !target.setLastModified(stamp)) {
throw new IOException(STAMP_ERR);
}
} else {
throw new IOException(TEMP_RENAME_ERR);
}
} else {
// just discard the temporary output file
if (!temp.delete()) {
throw new IOException(TEMP_DELETE_ERR);
}
// check if file needs to be renamed
if (!toext.equals(ext)) {
// just rename file for file option result
if (file.renameTo(target)) {
changed = true;
if (m_keepStamp && !target.setLastModified(stamp)) {
throw new IOException(STAMP_ERR);
}
} else {
throw new IOException(RENAME_ERR);
}
}
}
} else if (!toext.equals(ext)) {
// just rename file for file option result
in.close();
if (file.renameTo(target)) {
changed = true;
if (m_keepStamp && !target.setLastModified(stamp)) {
throw new IOException(STAMP_ERR);
}
} else {
throw new IOException(RENAME_ERR);
}
}
// check file listing
if (changed && (m_listProcessed || m_listModified)) {
System.out.println(" modified file " + file.getPath());
} else if (m_listProcessed) {
System.out.println(" checked file " + file.getPath());
}
return changed;
} catch (Exception ex) {
// report error
System.err.println("Error processing " + file.getPath());
System.err.println(ex.getMessage());
// discard temporary output file
if (temp != null) {
try {
temp.delete();
} catch (Exception ex2) {}
}
return false;
}
}
/**
* Checks if file or directory name directly matches a pattern. This
* method accepts one or more '*' wildcard characters in the pattern,
* calling itself recursively in order to handle multiple wildcards.
*
* @param name file or directory name
* @param pattern match pattern
* @return true if any pattern matched, false
* if not
*/
protected boolean isPathMatch(String name, String pattern) {
// check special match cases first
if (pattern.length() == 0) {
return name.length() == 0;
} else if (pattern.charAt(0) == '*') {
// check if the wildcard is all that's left of pattern
if (pattern.length() == 1) {
return true;
} else {
// check if another wildcard follows next segment of text
pattern = pattern.substring(1);
int split = pattern.indexOf('*');
if (split > 0) {
// recurse on each match to text segment
String piece = pattern.substring(0, split);
pattern = pattern.substring(split);
int offset = -1;
while ((offset = name.indexOf(piece, ++offset)) > 0) {
int end = offset + piece.length();
if (isPathMatch(name.substring(end), pattern)) {
return true;
}
}
} else {
// no more wildcards, need exact match to end of name
return name.endsWith(pattern);
}
}
} else {
// check for leading text before first wildcard
int split = pattern.indexOf('*');
if (split > 0) {
// match leading text to start of name
String piece = pattern.substring(0, split);
if (name.startsWith(piece)) {
return isPathMatch(name.substring(split),
pattern.substring(split));
} else {
return false;
}
} else {
// no wildcards, need exact match
return name.equals(pattern);
}
}
return false;
}
/**
* Checks if file name matches a pattern. This works a little differently
* from the general path matching in that if the pattern does not include
* an extension both ".java" and ".javx" file extensions are matched. If
* the pattern includes an extension ending in '*' it is blocked from
* matching with a tilde final character in the file name as a special case.
*
* @param name file or directory name
* @param pattern match pattern
* @return true if any file modified, false if not
*/
protected boolean isNameMatch(String name, String pattern) {
// check for extension included in pattern
if (pattern.indexOf('.') >= 0) {
// pattern includes extension, use as is except for tilde endings
if (name.charAt(name.length()-1) != '~' ||
pattern.charAt(pattern.length()-1) == '~') {
return isPathMatch(name, pattern);
}
} else {
// split extension from file name
int split = name.lastIndexOf('.');
if (split >= 0) {
// check for valid extension with match on name
String ext = name.substring(split+1);
if (ext.equals("java") || ext.equals("javx")) {
return isPathMatch(name.substring(0, split), pattern);
}
}
}
return false;
}
/**
* Process files matching path segment. This method matches a single step
* (directory specification) in a path for each call, calling itself
* recursively to match the complete path.
*
* @param base base directory for path match
* @param path file path remaining to be processed
*/
protected void matchPathSegment(File base, String path) {
// find break for leading directory if any in path
File[] files = base.listFiles();
int split = path.indexOf('/');
if (split >= 0) {
// split off the directory and check it
String dir = path.substring(0, split);
String next = path.substring(split+1);
if (dir.equals("**")) {
// match directly against files in this directory
matchPathSegment(base, next);
// walk all directories in tree under this one
for (int i = 0; i < files.length; i++) {
if (files[i].isDirectory()) {
matchPathSegment(files[i], path);
}
}
} else {
// try for concrete match to directory
for (int i = 0; i < files.length; i++) {
if (files[i].isDirectory()) {
if (isPathMatch(files[i].getName(), dir)) {
matchPathSegment(files[i], next);
}
}
}
}
} else {
// match directly against files in this directory
for (int i = 0; i < files.length; i++) {
if (!files[i].isDirectory()) {
if (isNameMatch(files[i].getName(), path)) {
m_matchedCount++;
if (processFile(files[i])) {
m_modifiedCount++;
}
}
}
}
}
}
/**
* Process all files matching path and print summary. The file path
* format is similar to Ant, supporting arbitrary directory recursion using
* '**' separators between '/' separators. Single '*'s may be used within
* names for wildcarding, but aside from the special case of the directory
* recursion matcher only one '*' may be used per name.
*
* If an extension is
* not specified for the final name in the path both ".java" and ".javx"
* extensions are checked, but after checking for file option lines (which
* may change the file extension) only ".java" extensions are processed for
* other source options.
*
* @param path file path to be processed
*/
protected void processPath(String path) {
// make sure we have something to process
if (path.length() > 0) {
// begin matching from root or current directory
if (path.charAt(0) == '/') {
matchPathSegment(new File(File.separator), path.substring(1));
} else {
matchPathSegment(new File("."), path);
}
// print summary information for path
if (m_listSummary) {
System.out.println(" matched " + m_matchedCount +
" files and modified " + m_modifiedCount +
" for path: " + path);
m_matchedCount = 0;
m_modifiedCount = 0;
}
}
}
/**
* Parse comma-separated token list. Parses and validates the tokens,
* adding them to the supplied list. errors are signalled by throwing
* IllegalArgumentException.
*
* @param list comma-separated token list to be parsed
* @param tokens list of tokens to add to
* @throws IllegalArgumentException on error in supplied list
*/
protected static void parseTokenList(String list, Vector tokens) {
// accumulate comma-delimited tokens from list
while (list.length() > 0) {
// find end for next token
int mark = list.indexOf(',');
String token;
if (mark == 0) {
throw new IllegalArgumentException("Empty token not " +
"allowed: \"" + list + '"');
} else if (mark > 0) {
// split token off list
token = list.substring(0, mark);
list = list.substring(mark+1);
} else {
// use rest of list as final token
token = list;
list = "";
}
// validate the token
for (int i = 0; i < token.length(); i++) {
char chr = token.charAt(i);
if ((i == 0 && !isTokenLeadChar(chr)) ||
(i > 0 && !isTokenBodyChar(chr))) {
throw new IllegalArgumentException("Illegal " +
"character in token: \"" + token + '"');
}
}
// add validated token to list
tokens.add(token);
}
}
/**
* Test driver, just reads the input parameters and executes the source
* checks.
*
* @param argv command line arguments
*/
public static void main(String[] argv) {
if (argv.length > 0) {
// parse the leading command line parameters
boolean valid = true;
boolean keep = false;
boolean listmod = false;
boolean quiet = false;
boolean tilde = false;
boolean verbose = false;
File backup = null;
Vector enables = new Vector();
Vector disables = new Vector();
int anum = 0;
while (anum < argv.length && argv[anum].charAt(0) == '-') {
String arg = argv[anum++];
int cnum = 1;
while (cnum < arg.length()) {
char option = Character.toLowerCase(arg.charAt(cnum++));
switch (option) {
case 'b':
if (anum < argv.length) {
try {
backup = new File(argv[anum++]);
if (!backup.isDirectory()) {
System.err.println("Backup directory " +
"path must be a directory");
}
} catch (SecurityException ex) {
System.err.println("Unable to access " +
"backup directory");
}
} else {
System.err.println("Missing directory path " +
"for -b option");
}
break;
case 'd':
case 'e':
if (anum < argv.length) {
// accumulate comma-delimited tokens from list
Vector tokens = (option == 'd') ?
disables : enables;
try {
parseTokenList(argv[anum++], tokens);
} catch (IllegalArgumentException ex) {
System.err.println(ex.getMessage());
return;
}
if (option == 'd') {
disables = tokens;
} else {
enables = tokens;
}
} else {
System.err.println("Missing token list for -" +
option + " option");
return;
}
break;
case 'p':
keep = true;
break;
case 'q':
quiet = true;
break;
case 'm':
listmod = true;
break;
case 't':
tilde = true;
break;
case 'v':
verbose = true;
break;
default:
System.err.println("Unknown option -" + option);
return;
}
}
}
// build hashsets of the tokens, checking for overlap
Hashtable enabled = new Hashtable();
for (int i = 0; i < enables.size(); i++) {
Object token = enables.elementAt(i);
enabled.put(token, token);
}
Hashtable disabled = new Hashtable();
for (int i = 0; i < disables.size(); i++) {
Object token = disables.elementAt(i);
disabled.put(token, token);
if (enabled.containsKey(token)) {
System.err.println(DUAL_USE_ERR + ": " + token);
return;
}
}
// construct an instance of class
JEnable opt = new JEnable(keep, tilde, listmod, quiet, verbose,
backup, enabled, disabled);
// check if we have file paths
if (anum < argv.length) {
// process each file path supplied
while (anum < argv.length) {
String arg = argv[anum++];
int split;
while ((split = arg.indexOf(',')) > 0) {
String path = arg.substring(0, split);
opt.processPath(path);
arg = arg.substring(split+1);
}
opt.processPath(arg);
}
} else {
// just process standard input to standard output
BufferedReader in = new BufferedReader
(new InputStreamReader(System.in));
BufferedWriter out = new BufferedWriter
(new OutputStreamWriter(System.out));
// check first line for disabled token
try {
String line = in.readLine();
int type = opt.checkOptionLine(1, line);
if (type == FILE_OPTION) {
boolean discard = opt.m_invert ?
enabled.contains(opt.m_token) :
disabled.contains(opt.m_token);
if (discard) {
return;
}
}
opt.processStream(in, line, out);
} catch (IOException ex) {
System.err.println(ex.getMessage());
}
}
} else {
System.err.println
("\nJEnable Java source configuration processor version " +
"0.8\nUsage: JEnable [-options] path-list\n" +
"Options are:\n" +
" -b backup directory tree (base directory is next " +
"argument)\n" +
" -d disabled token list (comma-separated token name list" +
" is next argument)\n" +
" -e enabled token list (comma-separated token name list" +
" is next argument)\n" +
" -m list modified files as they're processed\n" +
" -p preserve timestamp on modified files\n" +
" -q quiet mode, do not print file summary by path\n" +
" -t backup modified files in same directory with '~' " +
"suffix\n" +
" -v verbose listing of all files processed (modified or " +
"not)\n" +
"These options may be concatenated together with a single" +
" leading dash.\n\n" +
"Path lists may include '*' wildcards, and may consist of " +
"multiple paths\n" +
"separated by ',' characters. The special directory " +
"pattern '**' matches\n" +
"any number of intervening directories. Any number of path " +
"list parameters may\n" +
"be supplied.\n");
}
}
}
libjibx1.2-java-1.2.3/build/jenable/JEnable.class 0000644 0001750 0001750 00000026014 10434261436 021272 0 ustar twerner twerner Êþº¾ -õ
¦ ù ú û ü ý þ ÿ
ù
8
8
8
8
! ù
Œ
!
—
!
!!
¦"#
!$
8"%
Œ&
8'
(
)*
N+
@,
Œ-./
N0
H1
H2
834
H567
A8
@9:;
—&
8<=
H>?@
HA
HBCD
O8
NE
F
@G
NG
HH HI
HJ
HK
HLM
HN
HOPQ
^8R
`8
ST
UV
UG
SG
HW
HXYZ[\]^ _`a
bcde _fg
hi
j
8k
8l
Hmn
o
Hp
q r
s t Hu
H
vwxyz{
‡
|
Œ}~
Œ ù
€‚ƒ„
…†‡ˆ‰
— ù
ŒŠ
—‹Œ
Ž
‘ _’
“”
£•–— OPTION_LEAD Ljava/lang/String;
ConstantValue LEAD_LENGTH I COPY_BUFFER_SIZE
NOT_OPTION FILE_OPTION BLOCK_START_OPTION BLOCK_ELSE_OPTION BLOCK_END_OPTION BLOCK_COMMENT_OPTION FILE_OPTION_ERR NESTED_SAME_ERR INDETERM_ERR UNBALANCED_ERR BADELSE_ERR UNCLOSED_ERR UNKNOWN_OPTION_ERR
EXTENSION_ERR BACKUP_DIR_ERR˜ OLD_BACKUP_ERR BACKUP_FILE_ERR
DELETE_ERR
RENAME_ERR TEMP_RENAME_ERR TEMP_DELETE_ERR STAMP_ERR DUAL_USE_ERR™ m_keepStamp Z m_markBackup m_listModified m_listProcessed
m_listSummary m_backupDir Ljava/io/File; m_enabledTokens Ljava/util/Hashtable; m_disabledTokens m_matchedCount m_modifiedCount m_token m_invert m_endOffset @(ZZZZZLjava/io/File;Ljava/util/Hashtable;Ljava/util/Hashtable;)V Code isTokenLeadChar (C)Z isTokenBodyChar
throwError ((ILjava/lang/String;Ljava/lang/String;)V
Exceptions checkOptionLine (ILjava/lang/String;)I
processStream E(Ljava/io/BufferedReader;Ljava/lang/String;Ljava/io/BufferedWriter;)Z processFile (Ljava/io/File;)Z isPathMatch '(Ljava/lang/String;Ljava/lang/String;)Z isNameMatch matchPathSegment #(Ljava/io/File;Ljava/lang/String;)V processPath (Ljava/lang/String;)V parseTokenList '(Ljava/lang/String;Ljava/util/Vector;)V main ([Ljava/lang/String;)V ()V Ý ø Í Î Ï Î Ð Î Ñ Î Ò Î Ó Ô Õ Ö × Ö java/io/IOException java/lang/StringBuffer Error on input line š› šœ , :
ž Ý ò Ú ¨ Û Î Ü « Ÿ ª « //# ¡¢ £¤ à á â á ¥¦ unknown option line type ã ä java/util/Stack æ ç ,file option token must be first line of file §¨ @block option start cannot be nested within block with same token ©ª «¬ ® Cblock option token within enabled block must be enabled or disabled ¯° ±¬ (block option else without matching start ²° 'block option end without matching start ³¬ ¥´ šµ¶ · ò ¸ ø ¹ž º java/lang/String end of file with open block » ø ¼ž ½ž ¾¿ ÀÁ java/io/BufferedReader java/io/FileReader Ý Ýà java javx §¿ java/io/File ÝÄ "unknown file option line extension sop ÅÆ ÇÈ java/io/BufferedWriter java/io/FileWriter ÝÉ è é Ê ø Ëž ÌÍ Ý ð ή Ï® "unable to create backup directory
О Ñ® unable to delete old backup file java/io/FileInputStream java/io/FileOutputStreamÒ ·ÓÔ ÕÖ ×Ø Ù ë unable to rename file for backup unable to delete input file &unable to change file modify timestamp unable to rename temp file &unable to delete temporary output file unable to rename source fileÚ ÛÜ modified file Ý Þ ò checked file java/lang/Exception ßÜ Error processing à áž ì í §â 㢠äå ** ï ð æ® î í Ø « ê ë Ù « ç ¨ . matched files and modified for path: "java/lang/IllegalArgumentException Empty token not allowed: " Illegal character in token: " è¬ java/util/Vectoré êë )Backup directory path must be a directory java/lang/SecurityException !Unable to access backup directory $Missing directory path for -b option ó ô Missing token list for - option Unknown option - java/util/Hashtable ìí îï 0Same token cannot be both enabled and disabled: šð JEnable Ý Þ ñ ò java/io/InputStreamReader ñò Ýó java/io/OutputStreamWriter Ýô
JEnable Java source configuration processor version 0.8
Usage: JEnable [-options] path-list
Options are:
-b backup directory tree (base directory is next argument)
-d disabled token list (comma-separated token name list is next argument)
-e enabled token list (comma-separated token name list is next argument)
-m list modified files as they're processed
-p preserve timestamp on modified files
-q quiet mode, do not print file summary by path
-t backup modified files in same directory with '~' suffix
-v verbose listing of all files processed (modified or not)
These options may be concatenated together with a single leading dash.
Path lists may include '*' wildcards, and may consist of multiple paths
separated by ',' characters. The special directory pattern '**' matches
any number of intervening directories. Any number of path list parameters may
be supplied.
java/lang/Object !unable to create backup directory .Same token cannot be both enabled and disabled append ,(Ljava/lang/String;)Ljava/lang/StringBuffer; (I)Ljava/lang/StringBuffer; toString ()Ljava/lang/String; length ()I
startsWith (Ljava/lang/String;)Z charAt (I)C substring (II)Ljava/lang/String; indexOf (Ljava/lang/Object;)I push &(Ljava/lang/Object;)Ljava/lang/Object; containsKey (Ljava/lang/Object;)Z empty ()Z peek ()Ljava/lang/Object; equals pop contains (I)Ljava/lang/String; (C)Ljava/lang/StringBuffer; java/io/Writer write newLine readLine size flush getName getParent lastIndexOf (I)I lastModified ()J (Ljava/io/File;)V (Ljava/io/Reader;)V '(Ljava/lang/String;Ljava/lang/String;)V
getParentFile ()Ljava/io/File; createTempFile B(Ljava/lang/String;Ljava/lang/String;Ljava/io/File;)Ljava/io/File; (Ljava/io/Writer;)V close getCanonicalPath
separatorChar C exists mkdirs getPath delete java/io/OutputStream ([BII)V java/io/InputStream read ([B)I setLastModified (J)Z renameTo java/lang/System out Ljava/io/PrintStream; java/io/PrintStream println err java/lang/Throwable
getMessage (Ljava/lang/String;I)I endsWith listFiles ()[Ljava/io/File; isDirectory separator add java/lang/Character toLowerCase (C)C elementAt (I)Ljava/lang/Object; put 8(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ,(Ljava/lang/Object;)Ljava/lang/StringBuffer; in Ljava/io/InputStream; (Ljava/io/InputStream;)V (Ljava/io/OutputStream;)V ! ¦ ' § ¨ © ª « ¬ « © ® « © ¯ ° « © ± ² « © ³ ´ « © µ ¶ « © · ¸ « © ¹ º ¨ © $ » ¨ © & ¼ ¨ © * ½ ¨ © 0 ¾ ¨ © - ¿ ¨ © 9 À ¨ © Á ¨ © J Â ¨ © Ã Ä ¨ © ] Å ¨ © h Æ ¨ © i Ç ¨ © m È ¨ © k É ¨ © l Ê ¨ © j Ë ¨ © Ì Í Î Ï Î Ð Î Ñ Î Ò Î Ó Ô Õ Ö × Ö Ø « Ù « Ú ¨ Û Î Ü « Ý Þ ß F :*· *µ * µ * µ *µ *š § µ *µ *µ *µ ± à á ß 0 $a¡ z¤ A¡ Z¤ _ § ¬ â á ß < 0a¡ z¤ !A¡ Z¤ _Ÿ 0¡
9£ § ¬ ã ä ß 9 -»
Y» Y·
¶ ¶ ¶ -¶ ¶ ,¶ ¶ · ¿ å
æ ç ß 8 ,>*µ *µ *µ ,¶ ² ¤,¶ ™ ² 6,¶ 6!Ÿ
} „§ 66,¶ ¸ ™ Õ² `6§ Â,„¶ 6¸ š ¯*,d¶ µ *µ « ‹ * ) : y { J } g>! *µ § h™ c*, ¶ § X} >§ L! *µ >§ ;>™ 4*, ¶ § )>™ "*, ¶ § *, ¶ § ,¶ ¡ÿ; ¬ å
è é ß w k» !Y· ":» !Y· "::6,:6 §)6
* ¶ #6 ª Í ( . A Ë 6 —6
§¬ ¤¦* $¶ §™*´ ¶ %› * &¶ §€*´ ¶ 'WÇq*´ *´ ¶ (6 *´ *´ ¶ (6
*´ ™ 6
6 6
™ *´ :§6 ™ *´ ¶ 'W§$¶ )š * *¶ §¶ )š ¶ +*´ ¶ ,š * -¶ § ëÇ )¶ )š Þ¶ +*´ ¶ ,™ ϶ .W*´ :§ À*´ ¶ /™ ´:*´ ¶ 'W§ ¤¶ )š ¶ +*´ ¶ ,š * 0¶ § €¶ .WÇ #¶ )š m¶ +*´ ¶ ,™ ^¶ .W§ U*´ ¶ /™ I:§ CÆ *´ ¶ /™ Ç -*´ ¶ 1™ !*´ ¶ 2:6
6§
* ¶
š +Æ &» Y· ¶ ¶ :¶ 3¶ ¶ :6-¶ 4-¶ 5+¶ 6:„ Çýض 7ž * ¶ .À 89¶ -¶ :¬ å
ê ë ß á ÅM+¶ ;N+¶ <:-.¶ =6› -`¶ 2§ >::*´ ™
+¶ ?§ 7+:
» @Y» AY+· B· C: ¶ 6: * ¶ #6
D¶ /š
E¶ /™ ‚*´ *´ ¶ F™ *´ ™ E§ D:§ !*´ *´ ¶ F™ *´ ™ D§ E:¶ /š C-.¶ G6» Y· -¶ ¶ .¶ 3¶ ¶ N» HY-· I:
§
»
YJ· ¿6E¶ /šçK+¶ L¸ MM» NY» OY,· P· Q:* ¶ R6 ¶ S¶ T™d*´ Æ Ì+¶ U:² V¶ G6› `¶ 2:» HY*´ · W:¶ L:¶ Xš *¶ Yš "»
Y» Y· Z¶ ¶ [¶ ¶ · ¿¶ X™ ¶ \š
»
Y]· ¿ ¼:» ^Y+· _:» `Y· a:§
¶ b¶ cY6œÿì¶ d¶ e+¶ ?¶ fW*´ ™ N» HY» Y· -¶ ~¶ 3¶ · I:¶ X™ ¶ \š
»
Y]· ¿+¶ gš »
Yh· ¿+¶ \š
»
Yi· ¿,
¶ g™ *´ ™
¶ fš £»
Yj· ¿»
Yk· ¿,¶ \š
»
Yl· ¿¶ /š t+
¶ g™ !6*´ ™ a
¶ fš W»
Yj· ¿»
Ym· ¿¶ /š 9 ¶ S+
¶ g™ !6*´ ™ !
¶ fš »
Yj· ¿»
Ym· ¿™ 0*´ š
*´ ™ "² n» Y· o¶ +¶ [¶ ¶ ¶ p§ &*´ ™ ² n» Y· q¶ +¶ [¶ ¶ ¶ p¬N² s» Y· t¶ +¶ [¶ ¶ ¶ p² s-¶ u¶ p,Æ
,¶ \W§ :¬ ŽŽ r¹¾Á r ì í ß Â ¶,¶ š +¶ š § ¬,¶ * f,¶ ¬,¶ 2M,*¶ G> ž E, ¶ :, ¶ 2M6§ ¶ `6*+¶ 2,¶ v™ ¬+„¶ wY6ÿا <+,¶ x¬,*¶ G> ž %, ¶ :+¶ ™ *+ ¶ 2, ¶ 2¶ v¬¬+,¶ /¬¬ î í ß p d,.¶ G› (++¶ d¶ ~ ,,¶ d¶ ~ >*+,¶ v¬+.¶ => › ,+ `¶ 2:D¶ /š
E¶ /™ *+ ¶ ,¶ v¬¬ ï ð ß è Ü+¶ yN,/¶ G6› „,¶ :,`¶ 2:z¶ /™ 0*+¶ {6§ -2¶ |™ *-2,¶ {„-¾¡ÿæ§ ‚6§ *-2¶ |™ *-2¶ ;¶ v™
*-2¶ {„-¾¡ÿÕ§ K6§ >-2¶ |š 1*-2¶ ;,¶ }™ "*Y´ ~`µ ~*-2¶ ™
*Y´ €`µ €„-¾¡ÿÁ± ñ ò ß „ x+¶ ž s+¶ / *» HY² · ‚+¶ 2¶ {§ *» HYƒ· ‚+¶ {*´ ™ >² n» Y· „¶ *´ ~¶ …¶ *´ €¶ †¶ +¶ ¶ ¶ p*µ ~*µ €± ó ô ß · «§ £*,¶ G= š #» ‡Y» Y· ˆ¶ *¶ "¶ 3¶ · ‰¿ ž * ¶ N* `¶ 2K§ *N>K6§ H-¶ 6š ¸ ™ ž +¸ š #» ‡Y» Y· Š¶ -¶ "¶ 3¶ · ‰¿„-¶ ¡ÿµ+-¶ ‹W*¶ ÿ\± õ ö ß J
&*¾ž<=>666:» ŒY· :» ŒY· : 6
§p*
„
2: 6 §W „ ¶ ¸ Ž6
ª ( b v a ( £ £ ( ( ( ( ( ( ( ( ( ( ( ( "
*¾¢ 3» HY*
„
2· ‚:¶ |š ² s¶ p§ »:² s‘¶ p§ ®² s’¶ p§ £
*¾¢ E
d § :*
„
2¸ “§ :² s¶ u¶ p±
d
: § a:§ Z² s» Y· ”¶
¶ 3•¶ ¶ ¶ p±=§ 56§ />§ *6§ $6§ ² s» Y· –¶
¶ 3¶ ¶ p± ¶ ¡þ¥
*¾¢ *
2¶ -Ÿþ‚» —Y· ˜: 6 § ¶ ™:
¶ šW„ ¶ 7¡ÿã» —Y· ˜:
6§ > ¶ ™:
¶ šW ¶ (™ ² s» Y· ›¶ ¶ œ¶ ¶ p±„ ¶ 7¡ÿ¾» Y
· ž:
*¾¢ L§ ?*
„
2:§ ¶ :¶ Ÿ`¶ 2:,¶ GY6ÿÚ¶ Ÿ
*¾¡ÿÀ§ Ž» @Y» Y² ¡· ¢· C:» NY» £Y² n· ¤· Q:¶ 6:¶ #6 *´ ™ ´ ¶ F§
´ ¶ F6™ ±¶ RW§ :² s¶ u¶ p§ ² s¥¶ p± · × Ú ‡À
÷ ø ß ¶ ³ ± libjibx1.2-java-1.2.3/build/src/ 0000755 0001750 0001750 00000000000 11520371400 016115 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/schema-xsprefix-binding.xml 0000644 0001750 0001750 00000000643 11055552152 023370 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/src/wsdl-binding.xml 0000644 0001750 0001750 00000012705 11124147774 021244 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/src/class-customs-binding.xml 0000644 0001750 0001750 00000014307 11311274260 023060 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/src/binding-precomp.xml 0000644 0001750 0001750 00000005042 11055552152 021725 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/src/schema-base-binding.xml 0000644 0001750 0001750 00000061133 11257647764 022455 0 ustar twerner twerner
libjibx1.2-java-1.2.3/build/src/org/ 0000755 0001750 0001750 00000000000 11300355250 016705 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/ 0000755 0001750 0001750 00000000000 11300355306 017643 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/ 0000755 0001750 0001750 00000000000 11526304020 021323 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/RecoverableException.java 0000644 0001750 0001750 00000004303 10071714360 026304 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
/**
* Recoverable exception class. This is used for non-fatal errors in marshalling
* and unmarshalling.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class RecoverableException extends JiBXException
{
/**
* Constructor from message.
*
* @param msg message describing the exception condition
*/
public RecoverableException(String msg) {
super(msg);
}
/**
* Constructor from message and wrapped exception.
*
* @param msg message describing the exception condition
* @param root exception which caused this exception
*/
public RecoverableException(String msg, Throwable root) {
super(msg, root);
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/IUnmarshaller.java 0000644 0001750 0001750 00000007331 11043445700 024745 0 ustar twerner twerner /*
Copyright (c) 2002-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
/**
* Unmarshaller interface definition. This interface must be implemented
* by the handler for unmarshalling an object.
*
* Instances of classes implementing this interface must be serially
* reusable, meaning they can store state information while in the process
* of unmarshalling an object but must reset all state when called to
* unmarshal another object after the first one is done (even if the first
* object throws an exception during unmarshalling).
*
* The JiBX framework will only create one instance of an unmarshaller class
* (per unmarshalling context) for each mapped class using that unmarshaller.
* Generally the unmarshaller instance will not be called recursively, but this
* may happen in cases where the binding definition includes recursive mappings
* and the unmarshaller uses other unmarshallers (as opposed to handling all
* children directly).
*
* @author Dennis M. Sosnoski
*/
public interface IUnmarshaller
{
/**
* Check if instance present in XML. This method can be called when the
* unmarshalling context is positioned at or just before the start of the
* data corresponding to an instance of this mapping. It verifies that the
* expected data is present.
*
* @param ctx unmarshalling context
* @return true if expected parse data found,
* false if not
* @throws JiBXException on error in unmarshalling process
*/
boolean isPresent(IUnmarshallingContext ctx) throws JiBXException;
/**
* Unmarshal instance of handled class. This method call is responsible
* for all handling of the unmarshalling of an object from XML text,
* including creating the instance of the handled class if an instance is
* not supplied. When it is called the unmarshalling context is always
* positioned at or just before the start tag corresponding to the start of
* the class data.
*
* @param obj object to be unmarshalled (may be null)
* @param ctx unmarshalling context
* @return unmarshalled object (may be null)
* @throws JiBXException on error in unmarshalling process
*/
Object unmarshal(Object obj, IUnmarshallingContext ctx)
throws JiBXException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/IMarshallingContext.java 0000644 0001750 0001750 00000034075 11043445700 026123 0 ustar twerner twerner /*
Copyright (c) 2002-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import java.io.OutputStream;
import java.io.Writer;
/**
* User interface for serializer to XML. This provides methods used to set up
* and control the marshalling process, as well as access to the marshalling
* object stack while marshalling.
*
* @author Dennis M. Sosnoski
*/
public interface IMarshallingContext
{
/**
* Set output stream with encoding and escaper. This forces handling of the
* output stream to use the Java character encoding support with the
* supplied escaper.
*
* @param outs stream for document data output
* @param enc document output encoding, or null uses UTF-8
* default
* @param esc escaper for writing characters to stream
* @throws JiBXException if error setting output
*/
void setOutput(OutputStream outs, String enc, ICharacterEscaper esc)
throws JiBXException;
/**
* Set output stream and encoding.
*
* @param outs stream for document data output
* @param enc document output encoding, or null uses UTF-8
* default
* @throws JiBXException if error setting output
*/
void setOutput(OutputStream outs, String enc) throws JiBXException;
/**
* Set output writer and escaper.
*
* @param outw writer for document data output
* @param esc escaper for writing characters
*/
void setOutput(Writer outw, ICharacterEscaper esc);
/**
* Set output writer. This assumes the standard UTF-8 encoding.
*
* @param outw writer for document data output
*/
void setOutput(Writer outw);
/**
* Get the writer being used for output.
*
* @return XML writer used for output
*/
IXMLWriter getXmlWriter();
/**
* Set the writer being used for output.
*
* @param xwrite XML writer used for output
*/
void setXmlWriter(IXMLWriter xwrite);
/**
* Get current nesting indent spaces. This returns the number of spaces used
* to show indenting, if used.
*
* @return number of spaces indented per level, or negative if indentation
* disabled
*/
int getIndent();
/**
* Set nesting indent spaces. This is advisory only, and implementations of
* this interface are free to ignore it. The intent is to indicate that the
* generated output should use indenting to illustrate element nesting.
*
* @param count number of spaces to indent per level, or disable
* indentation if negative
*/
void setIndent(int count);
/**
* Set nesting indentation. This is advisory only, and implementations of
* this interface are free to ignore it. The intent is to indicate that the
* generated output should use indenting to illustrate element nesting.
*
* @param count number of character to indent per level, or disable
* indentation if negative (zero means new line only)
* @param newline sequence of characters used for a line ending
* (null means use the single character '\n')
* @param indent whitespace character used for indentation
*/
void setIndent(int count, String newline, char indent);
/**
* Reset to initial state for reuse. The context is serially reusable,
* as long as this method is called to clear any retained state information
* between uses. It is automatically called when output is set.
*/
void reset();
/**
* Start document, writing the XML declaration. This can only be validly
* called immediately following one of the set output methods; otherwise the
* output document will be corrupt.
*
* @param enc document encoding, null uses UTF-8 default
* @param alone standalone document flag, null if not
* specified
* @throws JiBXException on any error (possibly wrapping other exception)
*/
void startDocument(String enc, Boolean alone) throws JiBXException;
/**
* Start document with output stream and encoding. The effect is the same
* as from first setting the output stream and encoding, then making the
* call to start document.
*
* @param enc document encoding, null uses UTF-8 default
* @param alone standalone document flag, null if not
* specified
* @param outs stream for document data output
* @throws JiBXException on any error (possibly wrapping other exception)
*/
void startDocument(String enc, Boolean alone, OutputStream outs)
throws JiBXException;
/**
* Start document with writer. The effect is the same as from first
* setting the writer, then making the call to start document.
*
* @param enc document encoding, null uses UTF-8 default
* @param alone standalone document flag, null if not
* specified
* @param outw writer for document data output
* @throws JiBXException on any error (possibly wrapping other exception)
*/
void startDocument(String enc, Boolean alone, Writer outw)
throws JiBXException;
/**
* End document. Finishes all output and closes the document. Note that if
* this is called with an imcomplete marshalling the result will not be
* well-formed XML.
*
* @throws JiBXException on any error (possibly wrapping other exception)
*/
void endDocument() throws JiBXException;
/**
* Marshal document from root object without XML declaration. This can only
* be validly called immediately following one of the set output methods;
* otherwise the output document will be corrupt. The effect of this method
* is the same as the sequence of a call to marshal the root object using
* this context followed by a call to {@link #endDocument}.
*
* @param root object at root of structure to be marshalled, which must have
* a top-level mapping in the binding
* @throws JiBXException on any error (possibly wrapping other exception)
*/
void marshalDocument(Object root) throws JiBXException;
/**
* Marshal document from root object. This can only be validly called
* immediately following one of the set output methods; otherwise the output
* document will be corrupt. The effect of this method is the same as the
* sequence of a call to {@link #startDocument(String, Boolean)}, a call to
* marshal the root object using this context, and finally a call to
* {@link #endDocument}.
*
* @param root object at root of structure to be marshalled, which must have
* a top-level mapping in the binding
* @param enc document encoding, null uses UTF-8 default
* @param alone standalone document flag, null if not
* specified
* @throws JiBXException on any error (possibly wrapping other exception)
*/
void marshalDocument(Object root, String enc, Boolean alone)
throws JiBXException;
/**
* Marshal document from root object to output stream with encoding. The
* effect of this method is the same as the sequence of a call to {@link
* #startDocument(String, Boolean)}, a call to marshal the root object using
* this context, and finally a call to {@link #endDocument}.
*
* @param root object at root of structure to be marshalled, which must have
* a top-level mapping in the binding
* @param enc document encoding, null uses UTF-8 default
* @param alone standalone document flag, null if not
* specified
* @param outs stream for document data output
* @throws JiBXException on any error (possibly wrapping other exception)
*/
void marshalDocument(Object root, String enc, Boolean alone,
OutputStream outs) throws JiBXException;
/**
* Marshal document from root object to writer. The effect of this method
* is the same as the sequence of a call to {@link #startDocument(String,
* Boolean)}, a call to marshal the root object using this context, and
* finally a call to {@link #endDocument}.
*
* @param root object at root of structure to be marshalled, which must have
* a top-level mapping in the binding
* @param enc document encoding, null uses UTF-8 default
* @param alone standalone document flag, null if not
* specified
* @param outw writer for document data output
* @throws JiBXException on any error (possibly wrapping other exception)
*/
void marshalDocument(Object root, String enc, Boolean alone,
Writer outw) throws JiBXException;
/**
* Set a user context object. This context object is not used directly by
* JiBX, but can be accessed by all types of user extension methods. The
* context object is automatically cleared by the {@link #reset()} method,
* so to make use of this you need to first call the appropriate version of
* the setOutput() method, then this method, and finally one of
* the marshalDocument methods which uses the previously-set
* output (not the ones which take a stream or writer as parameter, since
* they call setOutput() themselves).
*
* @param obj user context object, or null if clearing existing
* context object
* @see #getUserContext()
*/
void setUserContext(Object obj);
/**
* Get the user context object.
*
* @return user context object, or null if no context object
* set
* @see #setUserContext(Object)
*/
Object getUserContext();
/**
* Push created object to marshalling stack. This must be called before
* beginning the marshalling of the object. It is only called for objects
* with structure, not for those converted directly to and from text.
*
* @param obj object being marshalled
*/
void pushObject(Object obj);
/**
* Pop marshalled object from stack.
*
* @throws JiBXException if no object on stack
*/
void popObject() throws JiBXException;
/**
* Get current marshalling object stack depth. This allows tracking
* nested calls to marshal one object while in the process of marshalling
* another object. The bottom item on the stack is always the root object
* of the marshalling.
*
* @return number of objects in marshalling stack
*/
int getStackDepth();
/**
* Get object from marshalling stack. This stack allows tracking nested
* calls to marshal one object while in the process of marshalling
* another object. The bottom item on the stack is always the root object
* of the marshalling.
*
* @param depth object depth in stack to be retrieved (must be in the range
* of zero to the current depth minus one).
* @return object from marshalling stack
*/
Object getStackObject(int depth);
/**
* Get top object on marshalling stack. This is safe to call even when no
* objects are on the stack.
*
* @return object from marshalling stack, or null if none
*/
Object getStackTop();
/**
* Find the marshaller for a particular class in the current context.
*
* @param mapname marshaller mapping name (generally the class name to be
* handled, or abstract mapping type name)
* @return marshalling handler for class
* @throws JiBXException on any error (possibly wrapping other exception)
*/
IMarshaller getMarshaller(String mapname) throws JiBXException;
/**
* Use namespace indexes from a separate binding, as identified by that
* binding's factory class name. The target binding must be a precompiled
* base binding of the binding used to create this marshalling context,
* either directly or by way of some other precompiled base binding(s).
*
* @param factname binding factory class name for binding defining
* namespaces
*/
void pushNamespaces(String factname);
/**
* End use of namespace indexes from a separate binding. This will undo the
* effect of the most-recent call to {@link #pushNamespaces(String)},
* restoring whatever namespace usage was in effect prior to that call.
*/
void popNamespaces();
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/PrintInfo.java 0000644 0001750 0001750 00000041044 11077370662 024121 0 ustar twerner twerner /*
* Copyright (c) 2008, Dennis M. Sosnoski. 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. Neither the name of JiBX nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 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 OWNER 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.jibx.runtime;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Map;
import org.jibx.runtime.impl.UnmarshallingContext;
/**
* Utility program to print information about the runtime build and, optionally,
* about bindings.
*
* @author Dennis M. Sosnoski
*/
public class PrintInfo
{
public static void main(String[] args) {
System.out.print("JiBX distribution ");
System.out.print(IBindingFactory.CURRENT_VERSION_NAME);
System.out.print(", version code ");
System.out.print(Integer
.toHexString(IBindingFactory.CURRENT_VERSION_NUMBER));
System.out.print("\n(compatible with binding compiler version codes ");
System.out.print(Integer
.toHexString(IBindingFactory.CURRENT_VERSION_NUMBER >> 16));
System.out.println("XXXX)");
boolean usage = false;
if (args.length > 0) {
// check for supported arguments
boolean verbose = false;
String bname = null;
String cname = null;
String pname = null;
for (int offset = 0; offset < args.length; offset++) {
String arg = args[offset];
if ("-v".equalsIgnoreCase(arg)) {
verbose = true;
} else if ("-b".equalsIgnoreCase(arg)) {
bname = args[++offset];
} else if ("-c".equalsIgnoreCase(arg)) {
cname = args[++offset];
} else if ("-p".equalsIgnoreCase(arg)) {
pname = args[++offset];
} else {
if (!"-?".equals(arg)) {
System.err.print("Unknown argument '");
System.out.print(arg);
System.out.println('\'');
}
usage = true;
break;
}
}
if (cname == null) {
if (bname != null && pname == null) {
System.err.println("Binding name requires package name or class name.");
usage = true;
} else if (bname == null && pname != null) {
System.err.println("Package name requires binding name.");
usage = true;
}
} else if (pname != null) {
if (cname.indexOf('.') > 0 && !cname.startsWith(pname)) {
System.err.println("When class and package names are both provided, the class must be in the package");
usage = true;
} else {
cname = pname + '.' + cname;
}
}
if (usage) {
System.out
.print("\nUsage: java org.jibx.runtime.PrintInfo "
+ "[-b bname] [-c cname] [-p pname] [-v]\nwith the optional"
+ " parameters:\n -b bname gives a binding name\n"
+ " -c cname gives a class name\n"
+ " -p pname gives a package name, and\n"
+ " -v turns on verbose output\n"
+ "If none of the name arguments are supplied the program "
+ "will just print the\nruntime version information and "
+ "exit. If one or more of the name parameters are\n"
+ "supplied, it will attempt to find a binding and list "
+ "the binding information.\nThe valid combinations of "
+ "arguments are a fully-qualified class name by itself,\n"
+ "when the class has a single binding; or a binding name "
+ "along with either a class\nname or a package name. The "
+ "target class or package must either be in the\n"
+ "classpath used for executing the program, or in the "
+ "path from the current\ndirectory. The 'verbose' flag "
+ "controls the level of detail included in the\nlisting.");
} else {
try {
IBindingFactory factory;
URL[] urls = new URL[] { new File(".").toURL() };
URLClassLoader loader = new URLClassLoader(urls);
if (cname == null) {
factory = BindingDirectory.getFactory(bname, pname,
loader);
} else {
Class clas = loader.loadClass(cname);
if (bname == null) {
factory = BindingDirectory.getFactory(clas);
} else {
factory = BindingDirectory.getFactory(bname, clas,
loader);
}
}
System.out.print("Found binding '");
System.out.print(factory.getBindingName());
System.out.print("' ");
int major = factory.getMajorVersion();
int minor = factory.getMinorVersion();
if (major != 0 || minor != 0) {
System.out.print("(version ");
System.out.print(major);
System.out.print(", ");
System.out.print(minor);
System.out.print(") ");
}
System.out.println();
System.out.print(" compiled with JiBX distribution ");
System.out.print(factory.getCompilerDistribution());
System.out.print(", version code ");
System.out.println(Integer.toHexString(factory
.getCompilerVersion()));
String[] nss = factory.getNamespaces();
String[] prefs = factory.getPrefixes();
if (prefs != null) {
if (nss.length > 2) {
System.out.print("Defines ");
System.out.print((nss.length - 2));
System.out.println(" namespace(s):");
for (int i = 1; i < prefs.length; i++) {
System.out.print(" ");
System.out.print(nss[i]);
if (prefs[i] == null) {
System.out.println(" (default namespace)");
} else {
System.out.print(" (prefix ");
System.out.print(prefs[i]);
System.out.println(')');
}
}
}
}
listBaseBindings(factory, verbose);
listClasses(factory, verbose);
listAbstracts(factory, verbose);
if (verbose) {
System.out.println("Classes containing binding code:");
String[] classes = factory.getBindingClasses();
for (int i = 0; i < classes.length; i++) {
System.out.print(" ");
System.out.println(classes[i]);
}
}
} catch (JiBXException ex) {
ex.printStackTrace(System.out);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
} else {
System.out.println("Use '-?' argument for usage details");
}
}
/**
* List class information from factory.
*
* @param factory
* @param verbose
*/
private static void listClasses(IBindingFactory factory, boolean verbose) {
String[] classes = factory.getMappedClasses();
String[] names = factory.getElementNames();
String[] uris = factory.getElementNamespaces();
String[] mars = factory.getMarshallerClasses();
String[] umars = factory.getUnmarshallerClasses();
System.out.print("Includes information for ");
System.out.print(classes.length);
System.out.println(" mapping(s):");
for (int i = 0; i < classes.length; i++) {
String clas = classes[i];
String name = null;
String mar = null;
if (mars != null && i < mars.length) {
mar = mars[i];
}
String umar = null;
if (umars != null && i < umars.length) {
umar = umars[i];
}
if ((i < names.length && (name = names[i]) != null) || mar != null
|| umar != null) {
if (name == null) {
System.out.print(" class ");
System.out.print(clas);
System.out.println(" abstract mapping");
} else {
System.out.print(" class ");
System.out.print(clas);
System.out.print(" mapped to element ");
System.out.println(UnmarshallingContext.buildNameString(
uris[i], name));
}
if (verbose) {
if (mar != null) {
System.out.print(" marshaller class ");
System.out.println(mar);
}
if (umar != null) {
System.out.print(" unmarshaller class ");
System.out.println(umar);
}
}
} else if (verbose) {
System.out.print(" reference to class or type ");
System.out.println(clas);
}
}
}
/**
* List precompiled base bindings from factory.
*
* @param factory
* @param verbose
*/
private static void listBaseBindings(IBindingFactory factory,
boolean verbose) {
String[] bases = factory.getBaseBindings();
if (bases.length > 0) {
String[] factories = factory.getBaseBindingFactories();
Map xlatemap = factory.getNamespaceTranslationTableMap();
System.out.println("Uses precompiled base binding(s):");
for (int i = 0; i < bases.length; i++) {
System.out.print(" ");
System.out.print(bases[i]);
System.out.print(" with binding factory ");
System.out.println(factories[i]);
int[] xlate = (int[])xlatemap.get(factories[i]);
if (verbose && xlate != null) {
System.out.println(" namespace translations:");
System.out.print(" ");
for (int j = 0; j < xlate.length; j++) {
System.out.print(' ');
System.out.print(xlate[j]);
}
}
System.out.println();
}
}
}
/**
* List abstract mappings from factory.
*
* @param factory
* @param verbose
*/
private static void listAbstracts(IBindingFactory factory, boolean verbose) {
String[][] abs = factory.getAbstractMappings();
int length = abs[0].length;
if (length > 0) {
System.out.print("Defines ");
System.out.print(length);
System.out.println(" abstract mapping(s):");
for (int i = 0; i < length; i++) {
String cname = abs[IBindingFactory.ABMAP_CLASSNAME_INDEX][i];
String tname = abs[IBindingFactory.ABMAP_MAPPINGNAME_INDEX][i];
System.out.print(" class ");
System.out.print(cname);
if (!cname.equals(tname)) {
System.out.print(" (type \"");
System.out.print(tname);
System.out.print("\")");
}
System.out.println();
if (verbose) {
int[] nss = factory.getAbstractMappingNamespaces(i);
if (nss.length > 0) {
System.out.print(" using namespace(s):");
for (int j = 0; j < nss.length; j++) {
System.out.print(" ");
System.out.print(nss[j]);
}
System.out.println();
}
String name = abs[IBindingFactory.ABMAP_CREATEMETH_INDEX][i];
if (name != null) {
System.out.print(" create method ");
System.out.println(name);
}
name = abs[IBindingFactory.ABMAP_COMPLETEMETH_INDEX][i];
if (name != null) {
System.out.print(" complete method ");
System.out.println(name);
}
name = abs[IBindingFactory.ABMAP_PREPAREMETH_INDEX][i];
if (name != null) {
System.out.print(" prepare method ");
System.out.println(name);
}
name = abs[IBindingFactory.ABMAP_ATTRPRESMETH_INDEX][i];
if (name != null) {
System.out.print(" attribute presence test method ");
System.out.println(name);
}
name = abs[IBindingFactory.ABMAP_ATTRUMARMETH_INDEX][i];
if (name != null) {
System.out.print(" attribute unmarshal method ");
System.out.println(name);
}
name = abs[IBindingFactory.ABMAP_ATTRMARMETH_INDEX][i];
if (name != null) {
System.out.print(" attribute marshal method ");
System.out.println(name);
}
name = abs[IBindingFactory.ABMAP_CONTPRESMETH_INDEX][i];
if (name != null) {
System.out.print(" content presence test method ");
System.out.println(name);
}
name = abs[IBindingFactory.ABMAP_CONTUMARMETH_INDEX][i];
if (name != null) {
System.out.print(" content unmarshal method ");
System.out.println(name);
}
name = abs[IBindingFactory.ABMAP_CONTMARMETH_INDEX][i];
if (name != null) {
System.out.print(" content marshal method ");
System.out.println(name);
}
}
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/Utility.java 0000644 0001750 0001750 00000232234 11362424654 023655 0 ustar twerner twerner /*
Copyright (c) 2002-2010, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import java.lang.reflect.Array;
//#!j2me{
import java.sql.Time;
import java.sql.Timestamp;
//#j2me}
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
/**
* Utility class supplying static methods. Date serialization is based on the
* algorithms published by Peter Baum (http://www.capecod.net/~pbaum). All date
* handling is done according to the W3C Schema specification, which uses a
* proleptic Gregorian calendar with no year 0. Note that this differs from the
* Java date handling, which uses a discontinuous Gregorian calendar.
*
* @author Dennis M. Sosnoski
*/
public abstract class Utility
{
/** Empty array of strings. */
public static final String[] EMPTY_STRING_ARRAY = new String[0];
/** Minimum size for array returned by {@link #growArray}. */
public static final int MINIMUM_GROWN_ARRAY_SIZE = 16;
/** Number of milliseconds in a minute. */
private static final int MSPERMINUTE = 60000;
/** Number of milliseconds in an hour. */
private static final int MSPERHOUR = MSPERMINUTE*60;
/** Number of milliseconds in a day. */
private static final int MSPERDAY = MSPERHOUR*24;
/** Number of milliseconds in a day as a long. */
private static final long LMSPERDAY = (long)MSPERDAY;
/** Number of milliseconds in a (non-leap) year. */
private static final long MSPERYEAR = LMSPERDAY*365;
/** Average number of milliseconds in a year within century. */
private static final long MSPERAVGYEAR = (long)(MSPERDAY*365.25);
/** Number of milliseconds in a normal century. */
private static final long MSPERCENTURY = (long)(MSPERDAY*36524.25);
/** Millisecond value of base time for internal representation. This gives
the bias relative to January 1 of the year 1 C.E. */
static final long TIME_BASE = 1969*MSPERYEAR + (1969/4 - 19 + 4)*LMSPERDAY;
/** Day number for start of month in non-leap year. */
static final int[] MONTHS_NONLEAP =
{
0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
};
/** Day number for start of month in non-leap year. */
static final int[] MONTHS_LEAP =
{
0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366
};
/** Millisecond count prior to start of month in March 1-biased year. */
private static final long[] BIAS_MONTHMS =
{
0*LMSPERDAY, 0*LMSPERDAY, 0*LMSPERDAY, 0*LMSPERDAY,
31*LMSPERDAY, 61*LMSPERDAY, 92*LMSPERDAY, 122*LMSPERDAY,
153*LMSPERDAY, 184*LMSPERDAY, 214*LMSPERDAY, 245*LMSPERDAY,
275*LMSPERDAY, 306*LMSPERDAY, 337*LMSPERDAY
};
/** Date for setting change to Gregorian calendar. */
private static Date BEGINNING_OF_TIME = new Date(Long.MIN_VALUE);
/** Pad character for base64 encoding. */
private static final char PAD_CHAR = '=';
/** Characters used in base64 encoding. */
private static final char[] s_base64Chars = {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', '+', '/'
};
/** Values corresponding to characters used in bas64 encoding. */
private static final byte[] s_base64Values = new byte[128];
static {
for (int i = 0; i < s_base64Values.length; i++) {
s_base64Values[i] = -1;
}
s_base64Values[PAD_CHAR] = 0;
for (int i = 0; i < s_base64Chars.length; i++) {
s_base64Values[s_base64Chars[i]] = (byte)i;
}
}
/**
* Parse digits in text as integer value. This internal method is used
* for number values embedded within lexical structures. Only decimal
* digits can be included in the text range parsed.
*
* @param text text to be parsed
* @param offset starting offset in text
* @param length number of digits to be parsed
* @return converted positive integer value
* @throws JiBXException on parse error
*/
static int parseDigits(String text, int offset, int length)
throws JiBXException {
// check if overflow a potential problem
int value = 0;
if (length > 9) {
// use library parse code for potential overflow
try {
value = Integer.parseInt(text.substring(offset, offset+length));
} catch (NumberFormatException ex) {
throw new JiBXException(ex.getMessage());
}
} else {
// parse with no overflow worries
int limit = offset + length;
while (offset < limit) {
char chr = text.charAt(offset++);
if (chr >= '0' && chr <= '9') {
value = value * 10 + (chr - '0');
} else {
throw new JiBXException("Non-digit in number value");
}
}
}
return value;
}
/**
* Parse integer value from text. Integer values are parsed with optional
* leading sign flag, followed by any number of digits.
*
* @param text text to be parsed
* @return converted integer value
* @throws JiBXException on parse error
*/
public static int parseInt(String text) throws JiBXException {
// make sure there's text to be processed
text = text.trim();
int offset = 0;
int limit = text.length();
if (limit == 0) {
throw new JiBXException("Empty number value");
}
// check leading sign present in text
boolean negate = false;
char chr = text.charAt(0);
if (chr == '-') {
if (limit > 9) {
// special case to make sure maximum negative value handled
try {
return Integer.parseInt(text);
} catch (NumberFormatException ex) {
throw new JiBXException(ex.getMessage());
}
} else {
negate = true;
offset++;
}
} else if (chr == '+') {
offset++;
}
if (offset >= limit) {
throw new JiBXException("Invalid number format");
}
// handle actual value conversion
int value = parseDigits(text, offset, limit-offset);
if (negate) {
return -value;
} else {
return value;
}
}
/**
* Serialize int value to text.
*
* @param value int value to be serialized
* @return text representation of value
*/
public static String serializeInt(int value) {
return Integer.toString(value);
}
/**
* Check if a text string is a valid boolean representation.
*
* @param text
* @return true if valid boolean, false if not
*/
public static boolean ifBoolean(String text) {
return "0".equals(text) || "1".equals(text) || "true".equals(text) ||
"false".equals(text);
}
/**
* Parse long value from text. Long values are parsed with optional
* leading sign flag, followed by any number of digits.
*
* @param text text to be parsed
* @return converted long value
* @throws JiBXException on parse error
*/
public static long parseLong(String text) throws JiBXException {
// make sure there's text to be processed
text = text.trim();
int offset = 0;
int limit = text.length();
if (limit == 0) {
throw new JiBXException("Empty number value");
}
// check leading sign present in text
boolean negate = false;
char chr = text.charAt(0);
if (chr == '-') {
negate = true;
offset++;
} else if (chr == '+') {
offset++;
}
if (offset >= limit) {
throw new JiBXException("Invalid number format");
}
// check if overflow a potential problem
long value = 0;
if (limit-offset > 18) {
// pass text to library parse code (less leading +)
if (chr == '+') {
text = text.substring(1);
}
try {
value = Long.parseLong(text);
} catch (NumberFormatException ex) {
throw new JiBXException(ex.getMessage());
}
} else {
// parse with no overflow worries
while (offset < limit) {
chr = text.charAt(offset++);
if (chr >= '0' && chr <= '9') {
value = value * 10 + (chr - '0');
} else {
throw new JiBXException("Non-digit in number value");
}
}
if (negate) {
value = -value;
}
}
return value;
}
/**
* Serialize long value to text.
*
* @param value long value to be serialized
* @return text representation of value
*/
public static String serializeLong(long value) {
return Long.toString(value);
}
/**
* Convert gYear text to Java date. Date values are expected to be in
* W3C XML Schema standard format as CCYY, with optional leading sign.
*
* @param text text to be parsed
* @return start of year date as millisecond value from 1 C.E.
* @throws JiBXException on parse error
*/
public static long parseYear(String text) throws JiBXException {
// start by validating the length
text = text.trim();
boolean valid = true;
int minc = 4;
char chr = text.charAt(0);
if (chr == '-') {
minc = 5;
} else if (chr == '+') {
valid = false;
}
if (text.length() < minc) {
valid = false;
}
if (!valid) {
throw new JiBXException("Invalid year format");
}
// handle year conversion
int year = parseInt(text);
if (year == 0) {
throw new JiBXException("Year value 0 is not allowed");
}
if (year > 0) {
year--;
}
long day = ((long)year)*365 + year/4 - year/100 + year/400;
return day*MSPERDAY - TIME_BASE;
}
/**
* Parse short value from text. Short values are parsed with optional
* leading sign flag, followed by any number of digits.
*
* @param text text to be parsed
* @return converted short value
* @throws JiBXException on parse error
*/
public static short parseShort(String text) throws JiBXException {
int value = parseInt(text);
if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
throw new JiBXException("Value out of range");
}
return (short)value;
}
/**
* Serialize short value to text.
*
* @param value short value to be serialized
* @return text representation of value
*/
public static String serializeShort(short value) {
return Short.toString(value);
}
/**
* Parse byte value from text. Byte values are parsed with optional
* leading sign flag, followed by any number of digits.
*
* @param text text to be parsed
* @return converted byte value
* @throws JiBXException on parse error
*/
public static byte parseByte(String text) throws JiBXException {
int value = parseInt(text);
if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
throw new JiBXException("Value out of range");
}
return (byte)value;
}
/**
* Serialize byte value to text.
*
* @param value byte value to be serialized
* @return text representation of value
*/
public static String serializeByte(byte value) {
return Byte.toString(value);
}
/**
* Parse boolean value from text. Boolean values are parsed as either text
* "true" and "false", or "1" and "0" numeric equivalents.
*
* @param text text to be parsed
* @return converted boolean value
* @throws JiBXException on parse error
*/
public static boolean parseBoolean(String text) throws JiBXException {
text = text.trim();
if ("true".equals(text) || "1".equals(text)) {
return true;
} else if ("false".equals(text) || "0".equals(text)) {
return false;
} else {
throw new JiBXException("Invalid boolean value");
}
}
/**
* Deserialize boolean value from text. If the text is null
* this just returns null; otherwise it returns the wrapped
* parsed value.
*
* @param text text to be parsed (may be null)
* @return converted Boolean value
* @throws JiBXException on parse error
*/
public static Boolean deserializeBoolean(String text) throws JiBXException {
if (text == null) {
return null;
} else {
return parseBoolean(text) ? Boolean.TRUE : Boolean.FALSE;
}
}
/**
* Serialize boolean value to text. This serializes the value using the
* text representation as "true" or "false".
*
* @param value boolean value to be serialized
* @return text representation of value
*/
public static String serializeBoolean(boolean value) {
return value ? "true" : "false";
}
/**
* Serialize boolean value to text. If the value is null this
* just returns null; otherwise it serializes the value using
* {@link #serializeBoolean(boolean)}.
*
* @param value value to be serialized
* @return text representation of value
*/
public static String serializeBoolean(Boolean value) {
if (value == null) {
return null;
} else {
return serializeBoolean(value.booleanValue());
}
}
/**
* Parse char value from text as unsigned 16-bit integer. Char values are
* parsed with optional leading sign flag, followed by any number of digits.
*
* @param text text to be parsed
* @return converted char value
* @throws JiBXException on parse error
*/
public static char parseChar(String text) throws JiBXException {
int value = parseInt(text);
if (value < Character.MIN_VALUE || value > Character.MAX_VALUE) {
throw new JiBXException("Value out of range");
}
return (char)value;
}
/**
* Serialize char value to text as unsigned 16-bit integer.
*
* @param value char value to be serialized
* @return text representation of value
*/
public static String serializeChar(char value) {
return Integer.toString(value);
}
/**
* Parse char value from text as character value. This requires that the
* string must be of length one.
*
* @param text text to be parsed
* @return converted char value
* @throws JiBXException on parse error
*/
public static char parseCharString(String text) throws JiBXException {
if (text.length() == 1) {
return text.charAt(0);
} else {
throw new JiBXException("Input must be a single character");
}
}
/**
* Deserialize char value from text as character value. This requires that
* the string must be null or of length one.
*
* @param text text to be parsed (may be null)
* @return converted char value
* @throws JiBXException on parse error
*/
public static char deserializeCharString(String text) throws JiBXException {
if (text == null) {
return 0;
} else {
return parseCharString(text);
}
}
/**
* Serialize char value to text as string of length one.
*
* @param value char value to be serialized
* @return text representation of value
*/
public static String serializeCharString(char value) {
return String.valueOf(value);
}
/**
* Parse float value from text. This uses the W3C XML Schema format for
* floats, with the exception that it will accept "+NaN" and "-NaN" as
* valid formats. This is not in strict compliance with the specification,
* but is included for interoperability with other Java XML processing.
*
* @param text text to be parsed
* @return converted float value
* @throws JiBXException on parse error
*/
public static float parseFloat(String text) throws JiBXException {
text = text.trim();
if ("-INF".equals(text)) {
return Float.NEGATIVE_INFINITY;
} else if ("INF".equals(text)) {
return Float.POSITIVE_INFINITY;
} else {
try {
return Float.parseFloat(text);
} catch (NumberFormatException ex) {
throw new JiBXException(ex.getMessage());
}
}
}
/**
* Serialize float value to text.
*
* @param value float value to be serialized
* @return text representation of value
*/
public static String serializeFloat(float value) {
if (Float.isInfinite(value)) {
return (value < 0.0f) ? "-INF" : "INF";
} else {
return Float.toString(value);
}
}
/**
* Parse double value from text. This uses the W3C XML Schema format for
* doubles, with the exception that it will accept "+NaN" and "-NaN" as
* valid formats. This is not in strict compliance with the specification,
* but is included for interoperability with other Java XML processing.
*
* @param text text to be parsed
* @return converted double value
* @throws JiBXException on parse error
*/
public static double parseDouble(String text) throws JiBXException {
text = text.trim();
if ("-INF".equals(text)) {
return Double.NEGATIVE_INFINITY;
} else if ("INF".equals(text)) {
return Double.POSITIVE_INFINITY;
} else {
try {
return Double.parseDouble(text);
} catch (NumberFormatException ex) {
throw new JiBXException(ex.getMessage());
}
}
}
/**
* Serialize double value to text.
*
* @param value double value to be serialized
* @return text representation of value
*/
public static String serializeDouble(double value) {
if (Double.isInfinite(value)) {
return (value < 0.0f) ? "-INF" : "INF";
} else {
return Double.toString(value);
}
}
/**
* Convert gYearMonth text to Java date. Date values are expected to be in
* W3C XML Schema standard format as CCYY-MM, with optional
* leading sign.
*
* @param text text to be parsed
* @return start of month in year date as millisecond value
* @throws JiBXException on parse error
*/
public static long parseYearMonth(String text) throws JiBXException {
// start by validating the length and basic format
text = text.trim();
boolean valid = true;
int minc = 7;
char chr = text.charAt(0);
if (chr == '-') {
minc = 8;
} else if (chr == '+') {
valid = false;
}
int split = text.length() - 3;
if (text.length() < minc) {
valid = false;
} else {
if (text.charAt(split) != '-') {
valid = false;
}
}
if (!valid) {
throw new JiBXException("Invalid date format");
}
// handle year and month conversion
int year = parseInt(text.substring(0, split));
if (year == 0) {
throw new JiBXException("Year value 0 is not allowed");
}
int month = parseDigits(text, split+1, 2) - 1;
if (month < 0 || month > 11) {
throw new JiBXException("Month value out of range");
}
boolean leap = (year%4 == 0) && !((year%100 == 0) && (year%400 != 0));
if (year > 0) {
year--;
}
long day = ((long)year)*365 + year/4 - year/100 + year/400 +
(leap ? MONTHS_LEAP : MONTHS_NONLEAP)[month];
return day*MSPERDAY - TIME_BASE;
}
/**
* Convert date text to Java date. Date values are expected to be in
* W3C XML Schema standard format as CCYY-MM-DD, with optional
* leading sign and trailing time zone (though the time zone is ignored
* in this case).
*
* Note that the returned value is based on UTC, which matches the
* definition of java.util.Date but will typically not be the
* expected value if you're using a java.util.Calendar on the
* result. In this case you probably want to instead use {@link
* #deserializeSqlDate(String)}, which does adjust the value to match
* the local time zone.
*
* @param text text to be parsed
* @return start of day in month and year date as millisecond value
* @throws JiBXException on parse error
*/
public static long parseDate(String text) throws JiBXException {
// start by validating the length and basic format
if (!ifDate(text)) {
throw new JiBXException("Invalid date format");
}
// handle year, month, and day conversion
int split = text.indexOf('-', 1);
int year = parseInt(text.substring(0, split));
if (year == 0) {
throw new JiBXException("Year value 0 is not allowed");
}
int month = parseDigits(text, split+1, 2) - 1;
if (month < 0 || month > 11) {
throw new JiBXException("Month value out of range");
}
long day = parseDigits(text, split+4, 2) - 1;
boolean leap = (year%4 == 0) && !((year%100 == 0) && (year%400 != 0));
int[] starts = leap ? MONTHS_LEAP : MONTHS_NONLEAP;
if (day < 0 || day >= (starts[month+1]-starts[month])) {
throw new JiBXException("Day value out of range");
}
if (year > 0) {
year--;
}
day += ((long)year)*365 + year/4 - year/100 + year/400 + starts[month];
return day*MSPERDAY - TIME_BASE;
}
/**
* Deserialize date from text. Date values are expected to match W3C XML
* Schema standard format as CCYY-MM-DD, with optional leading sign and
* trailing time zone (though the time zone is ignored in this case). This
* method follows standard JiBX deserializer usage requirements by accepting
* a null input.
*
* Note that the returned value is based on UTC, which matches the
* definition of java.util.Date but will typically not be the
* expected value if you're using a java.util.Calendar on the
* result. In this case you probably want to instead use {@link
* #deserializeSqlDate(String)}, which does adjust the value to match
* the local time zone.
*
* @param text text to be parsed (may be null)
* @return converted date, or null if passed null
* input
* @throws JiBXException on parse error
*/
public static Date deserializeDate(String text) throws JiBXException {
if (text == null) {
return null;
} else {
return new Date(parseDate(text));
}
}
//#!j2me{
/**
* Deserialize SQL date from text. Date values are expected to match W3C XML
* Schema standard format as CCYY-MM-DD, with optional leading sign and
* trailing time zone (though the time zone is ignored in this case). This
* method follows standard JiBX deserializer usage requirements by accepting
* a null input.
*
* @param text text to be parsed (may be null)
* @return converted date, or null if passed null
* input
* @throws JiBXException on parse error
*/
public static java.sql.Date deserializeSqlDate(String text)
throws JiBXException {
if (text == null) {
return null;
} else {
// make sure date is valid
if (!ifDate(text)) {
throw new JiBXException("Invalid date format");
}
// handle year, month, and day conversion
int split = text.indexOf('-', 1);
int year = parseInt(text.substring(0, split));
if (year == 0) {
throw new JiBXException("Year value 0 is not allowed");
}
int month = parseDigits(text, split+1, 2) - 1;
if (month < 0 || month > 11) {
throw new JiBXException("Month value out of range");
}
int day = parseDigits(text, split+4, 2) - 1;
boolean leap = (year%4 == 0) && !((year%100 == 0) && (year%400 != 0));
int[] starts = leap ? MONTHS_LEAP : MONTHS_NONLEAP;
if (day < 0 || day >= (starts[month+1]-starts[month])) {
throw new JiBXException("Day value out of range");
}
if (year < 0) {
year++;
}
// set it into a calendar
GregorianCalendar cal;
if (year < 1800) {
cal = new GregorianCalendar();
cal.setGregorianChange(BEGINNING_OF_TIME);
cal.clear();
cal.set(year, month, day+1);
} else {
cal = new GregorianCalendar(year, month, day+1);
}
return new java.sql.Date(cal.getTime().getTime());
}
}
//#j2me}
/**
* Parse general time value from text. Time values are expected to be in W3C
* XML Schema standard format as hh:mm:ss.fff, with optional leading sign
* and trailing time zone. This method ignores any time zone offset, just
* converting the value as supplied.
*
* @param text text to be parsed
* @param start offset of first character of time value
* @param length number of characters in time value
* @return converted time as millisecond value
* @throws JiBXException on parse error
*/
public static long parseTimeNoOffset(String text, int start, int length)
throws JiBXException {
// validate time value following date
long milli = 0;
boolean valid = length > (start+7) &&
(text.charAt(start+2) == ':') &&
(text.charAt(start+5) == ':');
if (valid) {
int hour = parseDigits(text, start, 2);
int minute = parseDigits(text, start+3, 2);
int second = parseDigits(text, start+6, 2);
if (hour > 24 || minute > 59 || second > 60 ||
(hour == 24 && (minute != 0 || second != 0))) {
valid = false;
} else {
// convert to base millisecond in day
milli = (((hour*60)+minute)*60+second)*1000;
int base = start + 8;
if (length > base) {
// check for trailing fractional second
if (text.charAt(base) == '.') {
int end = base + 1;
while (end < length) {
char chr = text.charAt(end);
if (chr < '0' || chr > '9') {
break;
} else {
end++;
}
}
double fraction = Double.parseDouble
(text.substring(base, end));
valid = hour < 24 || fraction == 0.0;
milli += fraction*1000.0;
}
}
}
}
// check for valid result
if (valid) {
return milli;
} else {
throw new JiBXException("Invalid time format: " + text);
}
}
/**
* Parse general time value from text. Time values are expected to be in W3C
* XML Schema standard format as hh:mm:ss.fff, with optional leading sign
* and trailing time zone. This method always adjusts the returned value to
* UTC if a time zone offset is supplied.
*
* @param text text to be parsed
* @param start offset of first character of time value
* @param length number of characters in time value
* @return converted time as millisecond value
* @throws JiBXException on parse error
*/
public static long parseTime(String text, int start, int length)
throws JiBXException {
// parse time and check for offset value
long milli = parseTimeNoOffset(text, start, length);
start += 8;
if (length > start) {
// adjust for time zone
if (text.charAt(length-1) == 'Z') {
length--;
} else {
char chr = text.charAt(length-6);
if (chr == '-' || chr == '+') {
int hour = parseDigits(text, length-5, 2);
int minute = parseDigits(text, length-2, 2);
if (hour > 14 || minute > 59 || (hour == 14 && minute != 0)) {
throw new JiBXException("Invalid time zone offset: " +
text);
} else {
int offset = ((hour*60)+minute)*60*1000;
if (chr == '-') {
milli += offset;
} else {
milli -= offset;
}
}
}
}
}
return milli;
}
/**
* Parse general dateTime value from text. Date values are expected to be in
* W3C XML Schema standard format as CCYY-MM-DDThh:mm:ss.fff, with optional
* leading sign and trailing time zone. This method always adjusts the
* returned value to UTC if a time zone offset is supplied.
*
* @param text text to be parsed
* @return converted date as millisecond value
* @throws JiBXException on parse error
*/
public static long parseDateTime(String text) throws JiBXException {
// split text to convert portions separately
int split = text.indexOf('T');
if (split < 0) {
throw new JiBXException("Missing 'T' separator in dateTime");
}
return parseDate(text.substring(0, split)) +
parseTime(text, split+1, text.length());
}
/**
* Deserialize date from general dateTime text. Date values are expected to
* match W3C XML Schema standard format as CCYY-MM-DDThh:mm:ss, with
* optional leading minus sign and trailing seconds decimal, as necessary.
* This method follows standard JiBX deserializer usage requirements by
* accepting a null input.
*
* @param text text to be parsed (may be null)
* @return converted date, or null if passed null
* input
* @throws JiBXException on parse error
*/
public static Date deserializeDateTime(String text) throws JiBXException {
if (text == null) {
return null;
} else {
return new Date(parseDateTime(text));
}
}
//#!j2me{
/**
* Deserialize timestamp from general dateTime text. Timestamp values are
* represented in the same way as regular dates, but allow more precision in
* the fractional second value (down to nanoseconds). This method follows
* standard JiBX deserializer usage requirements by accepting a
* null input.
*
* @param text text to be parsed (may be null)
* @return converted timestamp, or null if passed
* null input
* @throws JiBXException on parse error
*/
public static Timestamp deserializeTimestamp(String text)
throws JiBXException {
if (text == null) {
return null;
} else {
// check for fractional second value present
int split = text.indexOf('.');
int nano = 0;
if (split > 0) {
// make sure there aren't multiple decimal points
if (text.indexOf('.', split+1) > 0) {
throw new JiBXException("Not a valid timestamp value");
}
// scan through all digits following decimal point
int limit = text.length();
int scan = split;
while (++scan < limit) {
char chr = text.charAt(scan);
if (chr < '0' || chr > '9') {
break;
}
}
// parse digits following decimal point
int length = scan - split - 1;
if (length > 9) {
length = 9;
}
nano = parseDigits(text, split+1, length);
// convert to number of nanoseconds
while (length < 9) {
nano *= 10;
length++;
}
// strip fractional second off text
if (scan < limit) {
text = text.substring(0, split) + text.substring(scan);
} else {
text = text.substring(0, split);
}
}
// return timestamp value with nanoseconds
Timestamp stamp = new Timestamp(parseDateTime(text));
stamp.setNanos(nano);
return stamp;
}
}
/**
* Deserialize time from text. Time values obey the rules of the time
* portion of a dataTime value. This method follows standard JiBX
* deserializer usage requirements by accepting a null input.
*
* @param text text to be parsed (may be null)
* @return converted time, or null if passed null
* input
* @throws JiBXException on parse error
*/
public static Time deserializeSqlTime(String text)
throws JiBXException {
if (text == null) {
return null;
} else {
return new Time(parseTime(text, 0, text.length()));
}
}
//#j2me}
/**
* Format year number consistent with W3C XML Schema definitions, using a
* minimum of four digits padded with zeros if necessary. A leading minus
* sign is included for years prior to 1 C.E.
*
* @param year number to be formatted
* @param buff text formatting buffer
*/
protected static void formatYearNumber(long year, StringBuffer buff) {
// start with minus sign for dates prior to 1 C.E.
if (year <= 0) {
buff.append('-');
year = -(year-1);
}
// add padding if needed to bring to length of four
if (year < 1000) {
buff.append('0');
if (year < 100) {
buff.append('0');
if (year < 10) {
buff.append('0');
}
}
}
// finish by converting the actual year number
buff.append(year);
}
/**
* Format a positive number as two digits. This uses an optional leading
* zero digit for values less than ten.
*
* @param value number to be formatted (0 to 99)
* @param buff text formatting buffer
*/
protected static void formatTwoDigits(int value, StringBuffer buff) {
if (value < 10) {
buff.append('0');
}
buff.append(value);
}
/**
* Format time in milliseconds to year number. The resulting year number
* format is consistent with W3C XML Schema definitions, using a minimum
* of four digits padded with zeros if necessary. A leading minus sign is
* included for years prior to 1 C.E.
*
* @param value time in milliseconds to be converted (from 1 C.E.)
* @param buff text formatting buffer
*/
protected static void formatYear(long value, StringBuffer buff) {
// find the actual year and month number; this uses a integer arithmetic
// conversion based on Baum, first making the millisecond count
// relative to March 1 of the year 0 C.E., then using simple arithmetic
// operations to compute century, year, and month; it's slightly
// different for pre-C.E. values because of Java's handling of divisions.
long time = value + 306*LMSPERDAY + LMSPERDAY*3/4;
long century = time / MSPERCENTURY; // count of centuries
long adjusted = time + (century - (century/4)) * MSPERDAY;
int year = (int)(adjusted / MSPERAVGYEAR); // year in March 1 terms
if (adjusted < 0) {
year--;
}
long yms = adjusted + LMSPERDAY/4 - (year * 365 + year/4) * LMSPERDAY;
int yday = (int)(yms / LMSPERDAY); // day number in year
int month = (5*yday + 456) / 153; // (biased) month number
if (month > 12) { // convert start of year
year++;
}
// format year to text
formatYearNumber(year, buff);
}
/**
* Format time in milliseconds to year number and month number. The
* resulting year number format is consistent with W3C XML Schema
* definitions, using a minimum of four digits for the year and exactly
* two digits for the month.
*
* @param value time in milliseconds to be converted (from 1 C.E.)
* @param buff text formatting buffer
* @return number of milliseconds into month
*/
protected static long formatYearMonth(long value, StringBuffer buff) {
// find the actual year and month number; this uses a integer arithmetic
// conversion based on Baum, first making the millisecond count
// relative to March 1 of the year 0 C.E., then using simple arithmetic
// operations to compute century, year, and month; it's slightly
// different for pre-C.E. values because of Java's handling of divisions.
long time = value + 306*LMSPERDAY + LMSPERDAY*3/4;
long century = time / MSPERCENTURY; // count of centuries
long adjusted = time + (century - (century/4)) * MSPERDAY;
int year = (int)(adjusted / MSPERAVGYEAR); // year in March 1 terms
if (adjusted < 0) {
year--;
}
long yms = adjusted + LMSPERDAY/4 - (year * 365 + year/4) * LMSPERDAY;
int yday = (int)(yms / LMSPERDAY); // day number in year
if (yday == 0) { // special for negative
boolean bce = year < 0;
if (bce) {
year--;
}
int dcnt = year % 4 == 0 ? 366 : 365;
if (!bce) {
year--;
}
yms += dcnt * LMSPERDAY;
yday += dcnt;
}
int month = (5*yday + 456) / 153; // (biased) month number
long rem = yms - BIAS_MONTHMS[month] - LMSPERDAY; // ms into month
if (month > 12) { // convert start of year
year++;
month -= 12;
}
// format year and month as text
formatYearNumber(year, buff);
buff.append('-');
formatTwoDigits(month, buff);
// return extra milliseconds into month
return rem;
}
/**
* Format time in milliseconds to year number, month number, and day
* number. The resulting year number format is consistent with W3C XML
* Schema definitions, using a minimum of four digits for the year and
* exactly two digits each for the month and day.
*
* @param value time in milliseconds to be converted (from 1 C.E.)
* @param buff text formatting buffer
* @return number of milliseconds into day
*/
protected static int formatYearMonthDay(long value, StringBuffer buff) {
// convert year and month
long extra = formatYearMonth(value, buff);
// append the day of month
int day = (int)(extra / MSPERDAY) + 1;
buff.append('-');
formatTwoDigits(day, buff);
// return excess of milliseconds into day
return (int)(extra % MSPERDAY);
}
/**
* Serialize time to general gYear text. Date values are formatted in
* W3C XML Schema standard format as CCYY, with optional
* leading sign included if necessary.
*
* @param time time to be converted, as milliseconds from January 1, 1970
* @return converted gYear text
*/
public static String serializeYear(long time) {
StringBuffer buff = new StringBuffer(6);
formatYear(time + TIME_BASE, buff);
return buff.toString();
}
/**
* Serialize date to general gYear text. Date values are formatted in
* W3C XML Schema standard format as CCYY, with optional
* leading sign included if necessary.
*
* @param date date to be converted
* @return converted gYear text
*/
public static String serializeYear(Date date) {
return serializeYear(date.getTime());
}
/**
* Serialize time to general gYearMonth text. Date values are formatted in
* W3C XML Schema standard format as CCYY-MM, with optional
* leading sign included if necessary.
*
* @param time time to be converted, as milliseconds from January 1, 1970
* @return converted gYearMonth text
*/
public static String serializeYearMonth(long time) {
StringBuffer buff = new StringBuffer(12);
formatYearMonth(time + TIME_BASE, buff);
return buff.toString();
}
/**
* Serialize date to general gYearMonth text. Date values are formatted in
* W3C XML Schema standard format as CCYY-MM, with optional
* leading sign included if necessary.
*
* @param date date to be converted
* @return converted gYearMonth text
*/
public static String serializeYearMonth(Date date) {
return serializeYearMonth(date.getTime());
}
/**
* Serialize time to general date text. Date values are formatted in
* W3C XML Schema standard format as CCYY-MM-DD, with optional
* leading sign included if necessary.
*
* @param time time to be converted, as milliseconds from January 1, 1970
* @return converted date text
*/
public static String serializeDate(long time) {
StringBuffer buff = new StringBuffer(12);
formatYearMonthDay(time + TIME_BASE, buff);
return buff.toString();
}
/**
* Serialize date to general date text. Date values are formatted in
* W3C XML Schema standard format as CCYY-MM-DD, with optional
* leading sign included if necessary.
*
* Note that the conversion is based on UTC, which matches the
* definition of java.util.Date but may not match the value as
* serialized using java.util.Calendar (which assumes values
* are in the local time zone). To work with values in the local time zone
* you want to instead use {@link #serializeSqlDate(java.sql.Date)}.
*
* @param date date to be converted
* @return converted date text
*/
public static String serializeDate(Date date) {
return serializeDate(date.getTime());
}
//#!j2me{
/**
* Serialize SQL date to general date text. Date values are formatted in
* W3C XML Schema standard format as CCYY-MM-DD, with optional
* leading sign included if necessary. This interprets the date value with
* respect to the local time zone, as fits the definition of the
* java.sql.Date type.
*
* @param date date to be converted
* @return converted date text
*/
public static String serializeSqlDate(java.sql.Date date) {
// values should be normalized to midnight in zone, but no guarantee
// so convert using the lame calendar approach
GregorianCalendar cal = new GregorianCalendar();
cal.setGregorianChange(BEGINNING_OF_TIME);
cal.setTime(date);
StringBuffer buff = new StringBuffer(12);
int year = cal.get(Calendar.YEAR);
if (date.getTime() < 0) {
if (cal.get(Calendar.ERA) == GregorianCalendar.BC) {
year = -year + 1;
}
}
formatYearNumber(year, buff);
buff.append('-');
formatTwoDigits(cal.get(Calendar.MONTH)+1, buff);
buff.append('-');
formatTwoDigits(cal.get(Calendar.DAY_OF_MONTH), buff);
return buff.toString();
}
//#j2me}
/**
* Serialize time zone offset to buffer. Time zone offset values are always
* formatted in W3C XML Schema standard format as +/-hh:mm (even if the
* offset is zero).
*
* @param offset milliseconds to be subtracted to get UTC from local time
* @param buff buffer for appending time text
*/
public static void serializeExplicitOffset(int offset, StringBuffer buff) {
// start with sign of offset, and convert to absolute value
int abs;
if (offset < 0) {
abs = -offset;
buff.append('-');
} else {
abs = offset;
buff.append('+');
}
// append the hour and minute
formatTwoDigits(abs/MSPERHOUR, buff);
abs = abs % MSPERHOUR;
buff.append(':');
formatTwoDigits(abs/MSPERMINUTE, buff);
}
/**
* Serialize time zone offset to buffer. Time zone offset values are
* formatted in W3C XML Schema standard format as +/-hh:mm, with 'Z' used if
* the offset is zero.
*
* @param offset milliseconds to be subtracted to get UTC from local time
* @param buff buffer for appending time text
*/
public static void serializeOffset(int offset, StringBuffer buff) {
if (offset == 0) {
buff.append('Z');
} else {
serializeExplicitOffset(offset, buff);
}
}
/**
* Serialize time to general time text in buffer. Time values are formatted
* in W3C XML Schema standard format as hh:mm:ss, with optional trailing
* seconds decimal, as necessary. This form uses a supplied buffer to
* support flexible use, including with dateTime combination values.
*
* @param time time to be converted, as milliseconds in day
* @param buff buffer for appending time text
*/
public static void serializeTime(int time, StringBuffer buff) {
// append the hour, minute, and second
formatTwoDigits(time/MSPERHOUR, buff);
time = time % MSPERHOUR;
buff.append(':');
formatTwoDigits(time/MSPERMINUTE, buff);
time = time % MSPERMINUTE;
buff.append(':');
formatTwoDigits(time/1000, buff);
time = time % 1000;
// check if decimals needed on second
if (time > 0) {
buff.append('.');
buff.append(time / 100);
time = time % 100;
if (time > 0) {
buff.append(time / 10);
time = time % 10;
if (time > 0) {
buff.append(time);
}
}
}
}
/**
* Serialize time to general dateTime text. Date values are formatted in
* W3C XML Schema standard format as CCYY-MM-DDThh:mm:ss, with optional
* leading sign and trailing seconds decimal, as necessary.
*
* @param time time to be converted, as milliseconds from January 1, 1970
* @param zone flag for trailing 'Z' to be appended to indicate UTC
* @return converted dateTime text
*/
public static String serializeDateTime(long time, boolean zone) {
// start with the year, month, and day
StringBuffer buff = new StringBuffer(25);
int extra = formatYearMonthDay(time + TIME_BASE, buff);
// append the time for full form
buff.append('T');
serializeTime(extra, buff);
// return full text with optional trailing zone indicator
if (zone) {
buff.append('Z');
}
return buff.toString();
}
/**
* Serialize time to general dateTime text. This method is provided for
* backward compatibility. It generates the dateTime text without the
* trailing 'Z' to indicate UTC.
*
* @param time time to be converted, as milliseconds from January 1, 1970
* @return converted dateTime text
*/
public static String serializeDateTime(long time) {
return serializeDateTime(time, false);
}
/**
* Serialize date to general dateTime text. Date values are formatted in
* W3C XML Schema standard format as CCYY-MM-DDThh:mm:ssZ, with optional
* leading sign and trailing seconds decimal, as necessary.
*
* @param date date to be converted
* @return converted dateTime text
*/
public static String serializeDateTime(Date date) {
return serializeDateTime(date.getTime(), true);
}
//#!j2me{
/**
* Serialize timestamp to general dateTime text. Timestamp values are
* represented in the same way as regular dates, but allow more precision in
* the fractional second value (down to nanoseconds).
*
* @param stamp timestamp to be converted
* @return converted dateTime text
*/
public static String serializeTimestamp(Timestamp stamp) {
// check for nanosecond value to be included
int nano = stamp.getNanos();
if (nano > 0) {
// convert the number of nanoseconds to text
String value = serializeInt(nano);
// pad with leading zeros if less than 9 digits
StringBuffer digits = new StringBuffer(9);
if (value.length() < 9) {
int lead = 9 - value.length();
for (int i = 0; i < lead; i++) {
digits.append('0');
}
}
digits.append(value);
// strip trailing zeros from value
int last = 9;
while (--last >= 0) {
if (digits.charAt(last) != '0') {
break;
}
}
digits.setLength(last+1);
// finish by appending to rounded time with decimal separator
long time = stamp.getTime();
return serializeDateTime(time - time % 1000, false) + '.' +
digits + 'Z';
} else {
return serializeDateTime(stamp.getTime(), true);
}
}
/**
* Serialize time to standard text. Time values are formatted in W3C XML
* Schema standard format as hh:mm:ss, with optional trailing seconds
* decimal, as necessary. The standard conversion does not append a time
* zone indication.
*
* @param time time to be converted
* @return converted time text
*/
public static String serializeSqlTime(Time time) {
StringBuffer buff = new StringBuffer(12);
serializeTime((int)time.getTime(), buff);
return buff.toString();
}
//#j2me}
/**
* General object comparison method. Don't know why Sun hasn't seen fit to
* include this somewhere, but at least it's easy to write (over and over
* again).
*
* @param a first object to be compared
* @param b second object to be compared
* @return true if both objects are null, or if
* a.equals(b); false otherwise
*/
public static boolean isEqual(Object a, Object b) {
return (a == null) ? b == null : a.equals(b);
}
/**
* Find text value in enumeration. This first does a binary search through
* an array of allowed text matches. If a separate array of corresponding
* values is supplied, the value at the matched position is returned;
* otherwise the match index is returned directly.
*
* @param target text to be found in enumeration
* @param enums ordered array of texts included in enumeration
* @param vals array of values to be returned for corresponding text match
* positions (position returned directly if this is null)
* @return enumeration value for target text
* @throws JiBXException if target text not found in enumeration
*/
public static int enumValue(String target, String[] enums, int[] vals)
throws JiBXException {
int base = 0;
int limit = enums.length - 1;
while (base <= limit) {
int cur = (base + limit) >> 1;
int diff = target.compareTo(enums[cur]);
if (diff < 0) {
limit = cur - 1;
} else if (diff > 0) {
base = cur + 1;
} else if (vals != null) {
return vals[cur];
} else {
return cur;
}
}
throw new JiBXException("Target value \"" + target +
"\" not found in enumeration");
}
/**
* Decode a chunk of data from base64 encoding. The length of a chunk is
* always 4 characters in the base64 representation, but may be 1, 2, or 3
* bytes of data, as determined by whether there are any pad characters at
* the end of the base64 representation
*
* @param base starting offset within base64 character array
* @param chrs character array for base64 text representation
* @param fill starting offset within byte data array
* @param byts byte data array
* @return number of decoded bytes
*/
private static int decodeChunk(int base, char[] chrs, int fill,
byte[] byts) {
// find the byte count to be decoded
int length = 3;
if (chrs[base+3] == PAD_CHAR) {
length = 2;
if (chrs[base+2] == PAD_CHAR) {
length = 1;
}
}
// get 6-bit values
int v0 = s_base64Values[chrs[base+0]];
int v1 = s_base64Values[chrs[base+1]];
int v2 = s_base64Values[chrs[base+2]];
int v3 = s_base64Values[chrs[base+3]];
// convert and store bytes of data
switch (length) {
case 3:
byts[fill+2] = (byte)(v2 << 6 | v3);
case 2:
byts[fill+1] = (byte)(v1 << 4 | v2 >> 2);
case 1:
byts[fill] = (byte)(v0 << 2 | v1 >> 4);
break;
}
return length;
}
/**
* Parse base64 data from text. This converts the base64 data into a byte
* array of the appopriate length. In keeping with the recommendations,
*
* @param text text to be parsed (may include extra characters)
* @return byte array of data
* @throws JiBXException if invalid character in base64 representation
*/
public static byte[] parseBase64(String text) throws JiBXException {
// convert raw text to base64 character array
char[] chrs = new char[text.length()];
int length = 0;
for (int i = 0; i < text.length(); i++) {
char chr = text.charAt(i);
if (chr < 128 && s_base64Values[chr] >= 0) {
chrs[length++] = chr;
}
}
// check the text length
if (length % 4 != 0) {
throw new JiBXException
("Text length for base64 must be a multiple of 4");
} else if (length == 0) {
return new byte[0];
}
// find corresponding byte count for data
int blength = length / 4 * 3;
if (chrs[length-1] == PAD_CHAR) {
blength--;
if (chrs[length-2] == PAD_CHAR) {
blength--;
}
}
// convert text to actual bytes of data
byte[] byts = new byte[blength];
int fill = 0;
for (int i = 0; i < length; i += 4) {
fill += decodeChunk(i, chrs, fill, byts);
}
if (fill != blength) {
throw new JiBXException
("Embedded padding characters in byte64 text");
}
return byts;
}
/**
* Parse base64 data from text. This converts the base64 data into a byte
* array of the appopriate length. In keeping with the recommendations,
*
* @param text text to be parsed (may be null, or include extra characters)
* @return byte array of data
* @throws JiBXException if invalid character in base64 representation
*/
public static byte[] deserializeBase64(String text) throws JiBXException {
if (text == null) {
return null;
} else {
return parseBase64(text);
}
}
/**
* Encode a chunk of data to base64 encoding. Converts the next three bytes
* of data into four characters of text representation, using padding at the
* end of less than three bytes of data remain.
*
* @param base starting offset within byte array
* @param byts byte data array
* @param buff buffer for encoded text
*/
public static void encodeChunk(int base, byte[] byts, StringBuffer buff) {
// get actual byte data length to be encoded
int length = 3;
if (base + length > byts.length) {
length = byts.length - base;
}
// convert up to three bytes of data to four characters of text
int b0 = byts[base];
int value = (b0 >> 2) & 0x3F;
buff.append(s_base64Chars[value]);
if (length > 1) {
int b1 = byts[base+1];
value = ((b0 & 3) << 4) + ((b1 >> 4) & 0x0F);
buff.append(s_base64Chars[value]);
if (length > 2) {
int b2 = byts[base+2];
value = ((b1 & 0x0F) << 2) + ((b2 >> 6) & 3);
buff.append(s_base64Chars[value]);
value = b2 & 0x3F;
buff.append(s_base64Chars[value]);
} else {
value = (b1 & 0x0F) << 2;
buff.append(s_base64Chars[value]);
buff.append(PAD_CHAR);
}
} else {
value = (b0 & 3) << 4;
buff.append(s_base64Chars[value]);
buff.append(PAD_CHAR);
buff.append(PAD_CHAR);
}
}
/**
* Serialize byte array to base64 text. In keeping with the specification,
* this adds a line break every 76 characters in the encoded representation.
*
* @param byts byte data array
* @return base64 encoded text
*/
public static String serializeBase64(byte[] byts) {
StringBuffer buff = new StringBuffer((byts.length + 2) / 3 * 4);
for (int i = 0; i < byts.length; i += 3) {
encodeChunk(i, byts, buff);
if (i > 0 && i % 57 == 0 && (i + 3) < byts.length) {
buff.append("\r\n");
}
}
return buff.toString();
}
/**
* Resize array of arbitrary type.
*
* @param size new aray size
* @param base array to be resized
* @return resized array, with all data to minimum of the two sizes copied
*/
public static Object resizeArray(int size, Object base) {
int prior = Array.getLength(base);
if (size == prior) {
return base;
} else {
Class type = base.getClass().getComponentType();
Object copy = Array.newInstance(type, size);
int count = Math.min(size, prior);
System.arraycopy(base, 0, copy, 0, count);
return copy;
}
}
/**
* Grow array of arbitrary type. The returned array is double the size of
* the original array, providing this is at least the defined minimum size.
*
* @param base array to be grown
* @return array of twice the size as original array, with all data copied
*/
public static Object growArray(Object base) {
int length = Array.getLength(base);
Class type = base.getClass().getComponentType();
int newlen = Math.max(length*2, MINIMUM_GROWN_ARRAY_SIZE);
Object copy = Array.newInstance(type, newlen);
System.arraycopy(base, 0, copy, 0, length);
return copy;
}
/**
* Factory method to create a java.util.ArrayList as the
* implementation of a java.util.List.
*
* @return new java.util.ArrayList
*/
public static List arrayListFactory() {
return new ArrayList();
}
/**
* Convert whitespace-separated list of values. This implements the
* whitespace skipping, calling the supplied item deserializer for handling
* each individual value.
*
* @param text value to be converted
* @param ideser list item deserializer
* @return list of deserialized items (null if input
* null, or if nonrecoverable error)
* @throws JiBXException if error in deserializing text
*/
public static ArrayList deserializeList(String text,
IListItemDeserializer ideser) throws JiBXException {
if (text == null) {
return null;
} else {
// scan text to find whitespace breaks between items
ArrayList items = new ArrayList();
int length = text.length();
int base = 0;
boolean space = true;
for (int i = 0; i < length; i++) {
char chr = text.charAt(i);
switch (chr) {
case 0x09:
case 0x0A:
case 0x0D:
case ' ':
// ignore if preceded by space
if (!space) {
String itext = text.substring(base, i);
items.add(ideser.deserialize(itext));
space = true;
}
base = i + 1;
break;
default:
space = false;
break;
}
}
// finish last item
if (base < length) {
String itext = text.substring(base);
items.add(ideser.deserialize(itext));
}
// check if any items found
if (items.size() > 0) {
return items;
} else {
return null;
}
}
}
/**
* Deserialize a list of whitespace-separated tokens into an array of
* strings.
*
* @param text value text
* @return created class instance
* @throws JiBXException on error in marshalling
*/
public static String[] deserializeTokenList(String text) throws JiBXException {
// use basic qualified name deserializer to handle items
IListItemDeserializer ldser = new IListItemDeserializer() {
public Object deserialize(String text) throws JiBXException {
return text;
}
};
ArrayList list = Utility.deserializeList(text, ldser);
if (list == null) {
return null;
} else {
return (String[])list.toArray(new String[list.size()]);
}
}
/**
* Serialize an array of strings into a whitespace-separated token list.
*
* @param tokens array of strings to be serialized
* @return list text
*/
public static String serializeTokenList(String[] tokens) {
StringBuffer buff = new StringBuffer();
for (int i = 0; i < tokens.length; i++) {
if (buff.length() > 0) {
buff.append(' ');
}
buff.append(tokens[i]);
}
return buff.toString();
}
/**
* Safe equals test. This does an equals comparison for objects which may be
* null.
*
* @param a
* @param b
* @return true if both null or a.equals(b),
* false otherwise
*/
public static boolean safeEquals(Object a, Object b) {
if (a == null) {
return b == null;
} else {
return a.equals(b);
}
}
/**
* Check if a substring matches a supplied value.
*
* @param match comparison text
* @param text string to be compared
* @param offset starting offset for comparison
* @return true if substring match, false if not
*/
public static boolean ifEqualSubstring(String match, String text,
int offset) {
int length = match.length();
if (text.length() >= offset + length) {
for (int i = offset; i < length; i++) {
if (match.charAt(i) != text.charAt(offset+i)) {
return false;
}
}
return true;
}
return false;
}
/**
* Check if a text string is a valid integer subtype representation.
*
* @param text (non-null)
* @param digitmax maximum number of digits allowed
* @param abslimit largest absolute value allowed (null if no
* limit)
* @return true if valid representation, false if
* not
*/
public static boolean ifInIntegerRange(String text, int digitmax,
String abslimit) {
if (text.length() >= 1) {
// first skip past a leading sign character
int length = text.length();
int first = 0;
boolean negate = false;
char chr = text.charAt(0);
if (chr == '-') {
negate = true;
first = 1;
} else if (chr == '+') {
first = 1;
}
// scan for any non-digit characters, and to find first non-zero
for (int i = first; i < length; i++) {
chr = text.charAt(i);
if (chr < '0' || chr > '9') {
return false;
} else if (chr == '0' && i == first) {
first++;
}
}
// check if the digit count is allowed
int digitcnt = length - first;
if (digitcnt > digitmax) {
return false;
} else if (digitcnt == digitmax) {
String number = text;
if (first > 0) {
number = text.substring(first);
}
if (negate) {
return abslimit.compareTo(number) > 0;
} else {
return abslimit.compareTo(number) >= 0;
}
} else {
return true;
}
} else {
return false;
}
}
/**
* Check if a text string is a valid byte representation.
*
* @param text (non-null)
* @return true if valid byte, false if not
*/
public static boolean ifByte(String text) {
return ifInIntegerRange(text, 3, "128");
}
/**
* Check if a text string is a valid short representation.
*
* @param text (non-null)
* @return true if valid short, false if not
*/
public static boolean ifShort(String text) {
return ifInIntegerRange(text, 5, "32768");
}
/**
* Check if a text string is a valid int representation.
*
* @param text (non-null)
* @return true if valid int, false if not
*/
public static boolean ifInt(String text) {
return ifInIntegerRange(text, 10, "2147483648");
}
/**
* Check if a text string is a valid long representation.
*
* @param text (non-null)
* @return true if valid long, false if not
*/
public static boolean ifLong(String text) {
return ifInIntegerRange(text, 19, "9223372036854775808");
}
/**
* Check if a text string is a valid integer representation.
*
* @param text (non-null)
* @return true if valid integer, false if not
*/
public static boolean ifInteger(String text) {
return ifInIntegerRange(text, Integer.MAX_VALUE, null);
}
/**
* Check if a portion of a text string consists of decimal digits.
*
* @param text
* @param offset starting offset
* @param limit ending offset plus one (false return if the
* text length is less than this value)
* @return true if digits, false if not
*/
public static boolean ifDigits(String text, int offset, int limit) {
if (text.length() < limit) {
return false;
} else {
for (int i = offset; i < limit; i++) {
char chr = text.charAt(i);
if (chr < '0' || chr > '9') {
return false;
}
}
return true;
}
}
/**
* Check if a text string is a valid decimal representation.
*
* @param text (non-null)
* @return true if valid decimal, false if not
*/
public static boolean ifDecimal(String text) {
// empty string is never a valid decimal
if (text.length() == 0) {
return false;
}
// first skip past a leading sign character
int length = text.length();
int first = 0;
char chr = text.charAt(0);
if (chr == '-') {
first = 1;
} else if (chr == '+') {
first = 1;
}
// string consisting only of sign character is never a valid decimal
if (first == length) {
return false;
}
// scan for any non-digit characters
boolean decimal = false;
for (int i = first; i < length; i++) {
chr = text.charAt(i);
if (chr < '0' || chr > '9') {
if (!decimal && chr == '.') {
decimal = true;
} else {
return false;
}
}
}
return true;
}
/**
* Check if a portion of a text string is a bounded string of decimal
* digits. This is used for checking fixed-length decimal fields with a
* maximum value.
*
* @param text
* @param offset
* @param bound
* @return true if bounded decimal, false if not
*/
public static boolean ifFixedDigits(String text, int offset, String bound) {
int length = bound.length();
boolean lessthan = false;
for (int i = 0; i < length; i++) {
char chr = text.charAt(offset + i);
if (chr < '0' || chr > '9') {
return false;
} else if (!lessthan) {
int diff = bound.charAt(i) - chr;
if (diff > 0) {
lessthan = true;
} else if (diff < 0) {
return false;
}
}
}
return true;
}
/**
* Check if a text string ends with a valid zone suffix. This accepts an
* empty suffix, the single letter 'Z', or an offset of +/-HH:MM.
*
* @param text
* @param offset
* @return true if valid suffix, false if not
*/
public static boolean ifZoneSuffix(String text, int offset) {
int length = text.length();
if (length <= offset) {
return true;
} else {
char chr = text.charAt(offset);
if (length == offset+1 && chr == 'Z') {
return true;
} else if (length == offset+6 && (chr == '+' || chr == '-') &&
text.charAt(offset+3) == ':') {
if (ifEqualSubstring("14", text, offset+1)) {
return ifEqualSubstring("00", text, offset+4);
} else {
return ifFixedDigits(text, offset+1, "13") &&
ifFixedDigits(text, offset+4, "59");
}
} else {
return false;
}
}
}
/**
* Check if a text string follows the schema date format. This does not
* assure that the text string is actually a valid date representation,
* since it doesn't fully check the value ranges (such as the day number
* range for a particular month).
*
* @param text (non-null)
* @return true if date format, false if not
*/
public static boolean ifDate(String text) {
if (text.length() < 10) {
return false;
} else {
int base = 0;
int split = text.indexOf('-');
if (split == 0) {
base = 1;
split = text.indexOf('-', 1);
}
if (split > 0 && text.length() - split >= 5 &&
ifDigits(text, base, split) && text.charAt(split+3) == '-' &&
ifFixedDigits(text, split+1, "12") &&
ifFixedDigits(text, split+4, "31")) {
return ifZoneSuffix(text, split+6);
} else {
return false;
}
}
}
/**
* Check if a text string ends with a valid time suffix. This matches the
* format HH:MM:SS with optional training fractional seconds and optional
* time zone.
*
* @param text
* @param offset
* @return true if valid suffix, false if not
*/
public static boolean ifTimeSuffix(String text, int offset) {
if (text.length() - offset >= 8 &&
(ifEqualSubstring("24:00:00", text, offset) ||
(ifFixedDigits(text, offset, "23") &&
text.charAt(offset+2) == ':' &&
ifFixedDigits(text, offset+3, "59") &&
text.charAt(offset+5) == ':' &&
ifFixedDigits(text, offset+6, "60")))) {
int base = offset + 8;
int length = text.length();
if (base < length && text.charAt(base) == '.') {
while (++base < length) {
char chr = text.charAt(base);
if (chr < '0' || chr > '9') {
break;
}
}
}
return ifZoneSuffix(text, base);
} else {
return false;
}
}
/**
* Check if a text string follows the schema dateTime format. This does not
* assure that the text string is actually a valid dateTime representation,
* since it doesn't fully check the value ranges (such as the day number
* range for a particular month).
*
* @param text (non-null)
* @return true if date format, false if not
*/
public static boolean ifDateTime(String text) {
if (text.length() < 19) {
return false;
} else {
int base = 0;
int split = text.indexOf('-');
if (split == 0) {
base = 1;
split = text.indexOf('-', 1);
}
if (split > 0 && text.length() - split >= 14 &&
ifDigits(text, base, split) && text.charAt(split+3) == '-' &&
ifFixedDigits(text, split+1, "12") &&
ifFixedDigits(text, split+4, "31") &&
text.charAt(split+6) == 'T') {
return ifTimeSuffix(text, split+7);
} else {
return false;
}
}
}
/**
* Check if a text string follows the schema dateTime format. This does not
* assure that the text string is actually a valid dateTime representation,
* since it doesn't fully check the value ranges (such as the day number
* range for a particular month).
*
* @param text (non-null)
* @return true if date format, false if not
*/
public static boolean ifTime(String text) {
return ifTimeSuffix(text, 0);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/ITrackSource.java 0000644 0001750 0001750 00000004720 10071714354 024540 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
/**
* Unmarshalling source tracking interface. This interface is added to bound
* classes when requested by the binding definition. It allows the user to
* retrieve information about the location in the input document corresponding
* to an unmarshalled object, if the parser used for unmarshalling supports
* reporting this information.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public interface ITrackSource
{
/**
* Get source document name.
*
* @return name given for source document, or null if none
*/
public String jibx_getDocumentName();
/**
* Get source document line number.
*
* @return line number in source document, or -1 if unknown
*/
public int jibx_getLineNumber();
/**
* Get source document column number.
*
* @return column number in source document, or -1 if unknown
*/
public int jibx_getColumnNumber();
}
libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/IAbstractMarshaller.java 0000644 0001750 0001750 00000005316 10330637136 026073 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
/**
* Abstract base marshaller interface definition. This interface must be
* implemented by the handler for marshalling an object as an instance of a
* binding with extension mappings.
*
* This extension to the normal marshaller interface allows the base
* marshalling to determine the proper marshaller implementation to use at
* runtime. The code needs to check that the object to be marshalled has a
* marshaller that extends this base mapping.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public interface IAbstractMarshaller extends IMarshaller
{
/**
* Marshal instance of class with mapping extending this abstract mapping.
* This method call is responsible for all handling of the marshalling of an
* appropriate object to XML text. It is called at the point where the start
* tag for the associated element should be generated.
*
* @param obj object to be marshalled (may be null, in the case
* of a non-optional property with no value supplied)
* @param ctx XML text output context
* @throws JiBXException on error in marshalling process
*/
public void baseMarshal(Object obj, IMarshallingContext ctx)
throws JiBXException;
}
libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/IAliasable.java 0000644 0001750 0001750 00000006005 11257242110 024157 0 ustar twerner twerner /*
Copyright (c) 2002-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
/**
* Nameable extension interface definition. This interface must be implemented
* by a marshaller {@link org.jibx.runtime.IMarshaller} or unmarshaller {@link
* org.jibx.runtime.IUnmarshaller} that can use different top-level element
* names. Although it does not define any methods, it designates the marshaller
* or unmarshaller as being usable with a namespace and element name, and
* particular bound class name, defined within a binding.
*
* If this interface is implemented by a marshaller or unmarshaller class used
* with a specified element name in a binding the binding compiler will actually
* generate a subclass of the original class. The subclass uses a standard
* no-argument constructor, but calls a superclass constructor with the
* specified element name information. The superclass code can
* then make use of the specified name in marshalling and/or unmarshalling.
*
* For a marshaller-only class, the required constructor takes a pair of
* arguments, with the first argument the namespace URI index and the second the
* actual element name string. For an unmarshaller-only class, the constructor
* must take a pair of arguments, with the first argument the namespace URI and
* the second the element name. For a class which is both a marshaller and an
* unmarshaller, the constructor must take three arguments, with the first
* argument the namespace URI string, the second the namespace URI index, and
* the third the actual element name.
*
* @author Dennis M. Sosnoski
*/
public interface IAliasable {} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/UnrecoverableException.java 0000644 0001750 0001750 00000004307 10071714360 026653 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
/**
* Unrecoverable exception class. This is used for fatal errors in marshalling
* and unmarshalling.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class UnrecoverableException extends JiBXException
{
/**
* Constructor from message.
*
* @param msg message describing the exception condition
*/
public UnrecoverableException(String msg) {
super(msg);
}
/**
* Constructor from message and wrapped exception.
*
* @param msg message describing the exception condition
* @param root exception which caused this exception
*/
public UnrecoverableException(String msg, Throwable root) {
super(msg, root);
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/IXMLWriter.java 0000644 0001750 0001750 00000032550 11071456166 024157 0 ustar twerner twerner /*
Copyright (c) 2004-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import java.io.IOException;
/**
* XML writer interface used for output of marshalled document. This interface
* allows easy substitution of different output formats, including parse event
* stream equivalents. This makes heavy use of state information, so each
* method call defined is only valid in certain states.
*
* @author Dennis M. Sosnoski
*/
public interface IXMLWriter
{
/**
* Initialize writer.
*
* @throws IOException
*/
void init() throws IOException;
/**
* Get the current element nesting depth. Elements are only counted in the
* depth returned when they're officially open - after the start tag has
* been output and before the end tag has been output.
*
* @return number of nested elements at current point in output
*/
int getNestingDepth();
/**
* Get the number of namespaces currently defined. This is equivalent to the
* index of the next extension namespace added.
*
* @return namespace count
*/
int getNamespaceCount();
/**
* Set nesting indentation. This is advisory only, and implementations of
* this interface are free to ignore it. The intent is to indicate that the
* generated output should use indenting to illustrate element nesting.
*
* @param count number of character to indent per level, or disable
* indentation if negative (zero means new line only)
* @param newline sequence of characters used for a line ending
* (null means use the single character '\n')
* @param indent whitespace character used for indentation
*/
void setIndentSpaces(int count, String newline, char indent);
/**
* Write XML declaration to document. This can only be called before any
* other methods in the interface are called.
*
* @param version XML version text
* @param encoding text for encoding attribute (unspecified if
* null)
* @param standalone text for standalone attribute (unspecified if
* null)
* @throws IOException on error writing to document
*/
void writeXMLDecl(String version, String encoding, String standalone)
throws IOException;
/**
* Generate open start tag. This allows attributes and/or namespace
* declarations to be added to the start tag, but must be followed by a
* {@link #closeStartTag} call.
*
* @param index namespace URI index number
* @param name unqualified element name
* @throws IOException on error writing to document
*/
void startTagOpen(int index, String name) throws IOException;
/**
* Generate start tag for element with namespaces. This creates the actual
* start tag, along with any necessary namespace declarations. Previously
* active namespace declarations are not duplicated. The tag is
* left incomplete, allowing other attributes to be added.
*
* @param index namespace URI index number
* @param name element name
* @param nums array of namespace indexes defined by this element (must
* be constant, reference is kept until end of element)
* @param prefs array of namespace prefixes mapped by this element (no
* null values, use "" for default namespace declaration)
* @throws IOException on error writing to document
*/
void startTagNamespaces(int index, String name, int[] nums, String[] prefs)
throws IOException;
/**
* Add attribute to current open start tag. This is only valid after a call
* to {@link #startTagOpen} and before the corresponding call to {@link
* #closeStartTag}.
*
* @param index namespace URI index number
* @param name unqualified attribute name
* @param value text value for attribute
* @throws IOException on error writing to document
*/
void addAttribute(int index, String name, String value) throws IOException;
/**
* Close the current open start tag. This is only valid after a call to
* {@link #startTagOpen}.
*
* @throws IOException on error writing to document
*/
void closeStartTag() throws IOException;
/**
* Close the current open start tag as an empty element. This is only valid
* after a call to {@link #startTagOpen}.
*
* @throws IOException on error writing to document
*/
void closeEmptyTag() throws IOException;
/**
* Generate closed start tag. No attributes or namespaces can be added to a
* start tag written using this call.
*
* @param index namespace URI index number
* @param name unqualified element name
* @throws IOException on error writing to document
*/
void startTagClosed(int index, String name) throws IOException;
/**
* Generate end tag.
*
* @param index namespace URI index number
* @param name unqualified element name
* @throws IOException on error writing to document
*/
void endTag(int index, String name) throws IOException;
/**
* Write ordinary character data text content to document.
*
* @param text content value text (must not be null)
* @throws IOException on error writing to document
*/
void writeTextContent(String text) throws IOException;
/**
* Write CDATA text to document.
*
* @param text content value text (must not be null)
* @throws IOException on error writing to document
*/
void writeCData(String text) throws IOException;
/**
* Write comment to document.
*
* @param text comment text (must not be null)
* @throws IOException on error writing to document
*/
void writeComment(String text) throws IOException;
/**
* Write entity reference to document.
*
* @param name entity name (must not be null)
* @throws IOException on error writing to document
*/
void writeEntityRef(String name) throws IOException;
/**
* Write DOCTYPE declaration to document.
*
* @param name root element name
* @param sys system ID (null if none, must be
* non-null for public ID to be used)
* @param pub public ID (null if none)
* @param subset internal subset (null if none)
* @throws IOException on error writing to document
*/
void writeDocType(String name, String sys, String pub, String subset)
throws IOException;
/**
* Write processing instruction to document.
*
* @param target processing instruction target name (must not be
* null)
* @param data processing instruction data (must not be null)
* @throws IOException on error writing to document
*/
void writePI(String target, String data) throws IOException;
/**
* Request output indent. The writer implementation should normally indent
* output as appropriate. This method can be used to request indenting of
* output that might otherwise not be indented. The normal effect when used
* with a text-oriented writer should be to output the appropriate line end
* sequence followed by the appropriate number of indent characters for the
* current nesting level.
*
* @throws IOException on error writing to document
*/
void indent() throws IOException;
/**
* Flush document output. Writes any buffered data to the output medium.
* This does not flush the output medium itself, only any internal
* buffering within the writer.
*
* @throws IOException on error writing to document
*/
void flush() throws IOException;
/**
* Close document output. Completes writing of document output, including
* flushing and closing the output medium.
*
* @throws IOException on error writing to document
*/
void close() throws IOException;
/**
* Reset to initial state for reuse. The writer is serially reusable, as
* long as this method is called to clear any retained state information
* between uses.
*/
void reset();
/**
* Get namespace URIs for mapping. This gets the full ordered array of
* namespaces known in the binding used for this marshalling, where the
* index number of each namespace URI is the namespace index used to lookup
* the prefix when marshalling a name in that namespace. The returned array
* must not be modified.
*
* @return array of namespaces
*/
String[] getNamespaces();
/**
* Get URI for namespace.
*
* @param index namespace URI index number
* @return namespace URI text, or null if the namespace index
* is invalid
*/
String getNamespaceUri(int index);
/**
* Get current prefix defined for namespace.
*
* @param index namespace URI index number
* @return current prefix text, or null if the namespace is not
* currently mapped
*/
String getNamespacePrefix(int index);
/**
* Get index of namespace mapped to prefix. This can be an expensive
* operation with time proportional to the number of namespaces defined, so
* it should be used with care.
*
* @param prefix text to match (non-null, use "" for default
* prefix)
* @return index namespace URI index number mapped to prefix
*/
int getPrefixIndex(String prefix);
/**
* Append extension namespace URIs to those in mapping.
*
* @param uris namespace URIs to extend those in mapping
*/
void pushExtensionNamespaces(String[] uris);
/**
* Remove extension namespace URIs. This removes the last set of
* extension namespaces pushed using {@link #pushExtensionNamespaces}.
*/
void popExtensionNamespaces();
/**
* Get extension namespace URIs added to those in mapping. This gets the
* current set of extension definitions. The returned arrays must not be
* modified.
*
* @return array of arrays of extension namespaces (null if
* none)
*/
String[][] getExtensionNamespaces();
/**
* Open the specified namespaces for use. This method is normally only
* called internally, when namespace declarations are actually written to
* output. It is exposed as part of this interface to allow for special
* circumstances where namespaces are being written outside the usual
* processing. The namespaces will remain open for use until the current
* element is closed.
*
* @param nums array of namespace indexes defined by this element (reference
* kept until namespaces are closed, values may be modified by this method)
* @param prefs array of namespace prefixes mapped by this element (no
* null values, use "" for default namespace declaration)
* @return array of indexes for namespaces not previously active (the ones
* actually needing to be declared, in the case of text output)
* @throws IOException on error writing to document
*/
int[] openNamespaces(int[] nums, String[] prefs) throws IOException;
/**
* Push a translation table to be used for converting namespace index
* numbers passed as arguments to values used for internal lookup. This
* allows a layer of indirection between the client code and the
* namespace definitions, designed for use in supporting precompiled
* bindings. The translated values must match the internal tables.
*
* @param table translation table to be used (null if no
* change)
*/
void pushTranslationTable(int[] table);
/**
* Pop a translation table used for converting namespace index numbers to
* values matching the internal lookup.
*/
void popTranslationTable();
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/IBindingFactory.java 0000644 0001750 0001750 00000034443 11427247262 025227 0 ustar twerner twerner /*
Copyright (c) 2002-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import java.util.Map;
import org.jibx.runtime.impl.StringIntHashMap;
/**
* Binding factory interface definition. This interface is implemented by the
* binding factory class generated by each binding definition. All binding
* factory instances are guaranteed to be threadsafe and reusable.
*
* @author Dennis M. Sosnoski
*/
public interface IBindingFactory
{
/** Current binary version number. This is a byte-ordered value, allowing
for two levels of major and two levels of minor version. */
static final int CURRENT_VERSION_NUMBER = 0x00030000;
/** Current distribution file name. This is filled in by the Ant build
process to match the current distribution. */
static final String CURRENT_VERSION_NAME = "@distrib@";
/** Mask for portions of version number that effect compatibility. */
static final int COMPATIBLE_VERSION_MASK = 0xFFFF0000;
/** Abstract mapping details index for mapping (type or class) name. */
static final int ABMAP_MAPPINGNAME_INDEX = 0;
/** Abstract mapping details index for class name. */
static final int ABMAP_CLASSNAME_INDEX = 1;
/** Abstract mapping details index for new instance creation method. */
static final int ABMAP_CREATEMETH_INDEX = 2;
/** Abstract mapping details index for unmarshalling complete method. */
static final int ABMAP_COMPLETEMETH_INDEX = 3;
/** Abstract mapping details index for marshalling prepare method. */
static final int ABMAP_PREPAREMETH_INDEX = 4;
/** Abstract mapping details index for attribute presence test method. */
static final int ABMAP_ATTRPRESMETH_INDEX = 5;
/** Abstract mapping details index for attribute unmarshalling method. */
static final int ABMAP_ATTRUMARMETH_INDEX = 6;
/** Abstract mapping details index for attribute marshalling method. */
static final int ABMAP_ATTRMARMETH_INDEX = 7;
/** Abstract mapping details index for content presence test method. */
static final int ABMAP_CONTPRESMETH_INDEX = 8;
/** Abstract mapping details index for content unmarshalling method. */
static final int ABMAP_CONTUMARMETH_INDEX = 9;
/** Abstract mapping details index for content marshalling method. */
static final int ABMAP_CONTMARMETH_INDEX = 10;
/** Number of abstract mapping details. */
static final int ABMAP_COUNT = 11;
/**
* Create marshalling context instance.
*
* @return created marshalling context instance
* @throws JiBXException if error creating context
* @throws UnsupportedOperationException if marshalling not supported
* by binding
*/
IMarshallingContext createMarshallingContext() throws JiBXException;
/**
* Create unmarshalling context instance.
*
* @return created unmarshalling context instance
* @throws JiBXException if error creating context
* @throws UnsupportedOperationException if unmarshalling not supported
* by binding
*/
IUnmarshallingContext createUnmarshallingContext() throws JiBXException;
/**
* Get version number for binding compiler used.
*
* @return version number of code used to compile binding
*/
int getCompilerVersion();
/**
* Get distribution name for binding compiler used.
*
* @return name of distribution for binding compiler
*/
String getCompilerDistribution();
/**
* Get the name of this binding.
*
* @return name
*/
String getBindingName();
/**
* Get the major version number for this binding.
*
* @return major version
*/
int getMajorVersion();
/**
* Get the minor version number for this binding.
*
* @return minor version
*/
int getMinorVersion();
/**
* Get hash for binding. The computed hash value is based on all the values
* returned by all the methods of this interface, with the exception of the
* {@link #getMarshallerClass(int)} and {@link #getUnmarshallerClass(int)}
* methods returning Class objects.
*
* @return hash
*/
int getHash();
/**
* Get namespaces defined in mapping. The returned array is indexed by the
* namespace index number used when marshalling.
*
* @return array of namespaces defined in binding (null if not
* an output binding)
*/
String[] getNamespaces();
/**
* Get initial prefixes for namespaces defined in mapping. The returned
* array is indexed by the namespace index number used when marshalling.
* Note that these are only the first prefixes associated with each
* namespace; it's possible to reuse the namespace in the binding with a
* different prefix.
*
* @return array of prefixes for namespaces defined in binding
* (null if not an output binding)
*/
String[] getPrefixes();
/**
* Get mapped class names (or type names, in the case of abstract mappings).
* Returns array of fully-qualified class and/or type names, ordered by
* index number of the class.
*
* @return array of class names
*/
String[] getMappedClasses();
/**
* Get map from fully-qualified class name to the index number of the class
* used for accessing the arrays of class names. The value returned is the
* index for the class in the arrays returned by {@link
* #getMappedClasses()}, {@link #getMarshallerClasses()}, and {@link
* #getUnmarshallerClasses()}, and can also be used as input for {@link
* #getMarshallerClass(int)} and {@link #getUnmarshallerClass(int)}.
*
* @return map from fully-qualified class name to index number
*/
StringIntHashMap getClassIndexMap();
/**
* Get namespaces of elements corresponding to mapped classes. The returned
* array uses the same ordering as the result of the {@link
* #getMappedClasses} call. Entries in the array are null if
* there is no element for a class or the element is in the default
* namespace.
*
* @return array of element namespaces
*/
String[] getElementNamespaces();
/**
* Get names of elements corresponding to mapped classes. The returned array
* uses the same ordering as the result of the {@link #getMappedClasses}
* call. Entries in the array are null if there is no element
* for a class.
*
* @return array of element names
*/
String[] getElementNames();
/**
* Get marshaller class names. The returned array uses the same ordering as
* the result of the {@link #getMappedClasses} call. Entries in the array
* are null if there is no marshaller class for the mapping.
*
* @return array of class names
*/
String[] getMarshallerClasses();
/**
* Get unmarshaller class names. The returned array uses the same ordering
* as the result of the {@link #getMappedClasses} call. Entries in the array
* are null if there is no unmarshaller class for the mapping.
*
* @return array of class names
*/
String[] getUnmarshallerClasses();
/**
* Get mapped class index from type name for abstract non-base mappings
* included in the binding. This is intended to allow identifying and using
* abstract mappings (basically type mappings) at runtime. The method only
* returns a non-negative result if the "force-classes" option is used
* for the binding definition (since otherwise no marshaller/unmarshaller
* classes are created for abstract non-base mappings).
*
* @param type fully-qualified class or type name
* @return mapping index for type, or -1 if type is not an
* abstract non-base mapping
*/
int getTypeIndex(String type);
/**
* Get the classes used by the binding. Every class which includes code
* generated by the binding compiler for this binding or any precompiled
* base binding is included in the returned array. If {@link
* #verifyBaseBindings()} has not already been invoked it will be invoked by
* this call.
*
* @return fully-qualified class names
* @throws JiBXException on base binding verification error
*/
String[] getBindingClasses() throws JiBXException;
/**
* Get the linkage information for global abstract mappings included in the
* binding. The returned array has a primary (first index) dimension of 11
* and a secondary (second index) dimension equal to the number of global
* abstract mappings. The different index values for the first index give
* the following information:
*
* - 0 - mapping name (type or class)
* - 1 - class name
* - 2 - new instance creation method (
null if none)
* - 3 - unmarshalling complete method (
null if none)
* - 4 - prepare for marshalling method (
null if none)
* - 5 - attribute presence test method (
null if none)
* - 6 - attribute unmarshaller method (
null if none)
* - 7 - attribute marshaller method (
null if none)
* - 8 - content presence test method (
null if none)
* - 9 - content unmarshaller method (
null if none)
* - 10 - content marshaller method (
null if none)
*
* The method specifications are in the form of fully qualified class names
* and method signatures. The methods are only intended for use by the
* binding compiler when working with a precompiled binding.
*
* @return method information array
*/
String[][] getAbstractMappings();
/**
* Get the indexes of the namespaces used by an abstract mapping.
*
* @param index abstract mapping index, corresponding to the abstract
* mapping information returned by {@link #getAbstractMappings()}.
* @return namespace indexes, empty array if none
*/
int[] getAbstractMappingNamespaces(int index);
/**
* Get the mapping from element local name to class indexes. If a local name
* is only used with a single namespace, the value for that name is an
* Integer giving the index of the class mapped to the name; if
* the local name is used with multiple namespaces, the value for that name
* is an array with multiple int class indexes, for every class
* mapped to the name.
*
* @return map from local name to class index array
*/
Map getUnmarshalMap();
/**
* Get the unmarshaller class for a mapping. This can only be used for
* global mappings.
*
* @param index unmarshaller class index
* @return unmarshaller class, or null if unable to load class
*/
Class getUnmarshallerClass(int index);
/**
* Get the marshaller class for a mapping. This can only be used for global
* mappings.
*
* @param index marshaller class index
* @return marshaller class, or null if unable to load class
*/
Class getMarshallerClass(int index);
/**
* Get the names of the separately-compiled base bindings used by this
* binding.
*
* @return binding names
*/
String[] getBaseBindings();
/**
* Verify that separately-compiled base bindings used by this binding can be
* loaded and are compatible with the base bindings used when this binding
* was compiled.
*
* @throws JiBXException on verification failure
*/
void verifyBaseBindings() throws JiBXException;
/**
* Get the names of the binding factory classes for the separately-compiled
* base bindings used by this binding.
*
* @return binding factory fully-qualified class names
*/
String[] getBaseBindingFactories();
/**
* Get a map from full-qualified binding factory names to an array of
* int values used to convert namespace indexes in that binding
* to this binding. If the binding uses the same namespaces as this binding
* (or a subset of the same namespaces, with the same index values) there is
* no entry in the map.
*
* @return map to namespace index translation
*/
Map getNamespaceTranslationTableMap();
/**
* Load a class. This first tries to load the specified class using the
* classloader that loaded the binding factory instance, then tries the
* thread context classloader, then finally tries the classloader used to
* load core runtime classes.
*
* @param name fully qualified class name
* @return loaded class, or null if class not found
*/
Class loadClass(String name);
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/JodaConvert.java 0000644 0001750 0001750 00000052562 11260446140 024423 0 ustar twerner twerner /*
Copyright (c) 2009, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import org.joda.time.DateMidnight;
import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
import org.joda.time.LocalDate;
import org.joda.time.LocalTime;
/**
* Utility class supplying static methods for Joda date/time conversions. The actual serializer/deserializer methods are
* all public so that they'll be included in JavaDocs; support methods are protected, so that they'll be exposed for
* user classes extending this class.
*
* @author Dennis M. Sosnoski
*/
public abstract class JodaConvert
{
/**
* Deserialize date value from text as local date without time zone. Date values are expected to match W3C XML
* Schema standard format as CCYY-MM-DD, with optional leading sign and trailing time zone (with the time zone
* ignored in this case). This method follows standard JiBX deserializer usage requirements by accepting a
* null input.
*
* @param text text to be parsed (may be null)
* @return converted date, or null if passed null input
* @throws JiBXException on parse error
*/
public static LocalDate deserializeLocalDate(String text) throws JiBXException {
if (text == null) {
return null;
} else {
return new LocalDate(Utility.parseDate(text), DateTimeZone.UTC);
}
}
/**
* Serialize local date value to general date text without time zone. Date/time values are formatted in W3C XML
* Schema standard format as CCYY-MM-DD, with optional leading sign included if necessary.
*
* @param date date to be converted
* @return converted date text
*/
public static String serializeLocalDate(LocalDate date) {
return Utility.serializeDate(date.toDateTimeAtStartOfDay(DateTimeZone.UTC).getMillis());
}
/**
* Deserialize date value as a midnight date in the specified time zone.
*
* @param text
* @param zone
* @return date
* @throws JiBXException
*/
protected static DateMidnight deserializeDateMidnight(String text, DateTimeZone zone) throws JiBXException {
// start by validating the length and basic format
if (!Utility.ifDate(text)) {
throw new JiBXException("Invalid date format");
}
// handle year, month, and day conversion
int split = text.indexOf('-', 1);
int year = Utility.parseInt(text.substring(0, split));
if (year == 0) {
throw new JiBXException("Year value 0 is not allowed");
}
int month = Utility.parseDigits(text, split+1, 2);
if (month < 1 || month > 12) {
throw new JiBXException("Month value out of range");
}
int day = Utility.parseDigits(text, split+4, 2);
boolean leap = (year%4 == 0) && !((year%100 == 0) && (year%400 != 0));
int[] starts = leap ? Utility.MONTHS_LEAP : Utility.MONTHS_NONLEAP;
if (day < 1 || day > (starts[month]-starts[month-1])) {
throw new JiBXException("Day value out of range");
}
// return resulting value
return new DateMidnight(year, month, day, zone);
}
/**
* Find the date/time zone for an xs:date or xs:dateTime text representation.
*
* @param text xs:date or xs:dateTime value
* @param dflt default zone to be returned if no zone specified
* @return zone
* @throws JiBXException
*/
protected static DateTimeZone findZone(String text, DateTimeZone dflt) throws JiBXException {
// check for UTC time zone offset indicator
int length = text.length();
if (text.charAt(length-1) == 'Z') {
return DateTimeZone.UTC;
} else {
// make sure time zone start offset is not year/month separator in date
int offset = length - 6;
if (text.indexOf('-', 1) < offset) {
// check for time zone offset present as +/-hh:mm
char chr = text.charAt(offset);
if (chr == '-' || chr == '+') {
int hour = Utility.parseDigits(text, offset+1, 2);
int minute = Utility.parseDigits(text, offset+4, 2);
if (hour > 14 || minute > 59 || (hour == 14 && minute != 0)) {
throw new JiBXException("Invalid time zone offset: " + text);
} else if (chr == '-') {
return DateTimeZone.forOffsetHoursMinutes(-hour, minute);
} else {
return DateTimeZone.forOffsetHoursMinutes(hour, minute);
}
}
}
return dflt;
}
}
/**
* Deserialize date value from text as midnight date in specified (or default) time zone. Date values are expected
* to match W3C XML Schema standard format as CCYY-MM-DD, with optional leading sign and trailing time zone. If the
* time zone indication is included a zone matching the offset is used for the date; otherwise the default time zone
* is used. This method follows standard JiBX deserializer usage requirements by accepting a null
* input.
*
* @param text text to be parsed (may be null)
* @return converted date, or null if passed null input
* @throws JiBXException on parse error
*/
public static DateMidnight deserializeZonedDateMidnight(String text) throws JiBXException {
if (text == null) {
return null;
} else {
DateTimeZone zone = findZone(text, DateTimeZone.getDefault());
return deserializeDateMidnight(text, zone);
}
}
/**
* Deserialize date value from text as midnight date in default (local) time zone. Date values are expected to match
* W3C XML Schema standard format as CCYY-MM-DD, with optional leading sign and trailing time zone (with the time
* zone ignored in this case). This method follows standard JiBX deserializer usage requirements by accepting a
* null input.
*
* @param text text to be parsed (may be null)
* @return converted date, or null if passed null input
* @throws JiBXException on parse error
*/
public static DateMidnight deserializeLocalDateMidnight(String text) throws JiBXException {
if (text == null) {
return null;
} else {
return deserializeDateMidnight(text, DateTimeZone.getDefault());
}
}
/**
* Deserialize date value from text as midnight date in UTC time zone. Date values are expected to match W3C XML
* Schema standard format as CCYY-MM-DD, with optional leading sign and trailing time zone (with the time zone
* ignored in this case). This method follows standard JiBX deserializer usage requirements by accepting a
* null input.
*
* @param text text to be parsed (may be null)
* @return converted date, or null if passed null input
* @throws JiBXException on parse error
*/
public static DateMidnight deserializeUTCDateMidnight(String text) throws JiBXException {
if (text == null) {
return null;
} else {
return deserializeDateMidnight(text, DateTimeZone.UTC);
}
}
/**
* Serialize midnight date value to general date text without time zone. Date values are formatted in W3C XML Schema
* standard format as CCYY-MM-DD, with optional leading sign included if necessary.
*
* @param date date to be converted
* @return converted date text
*/
public static String serializeUnzonedDateMidnight(DateMidnight date) {
long millis = date.getMillis();
int offset = date.getZone().getOffset(millis);
return Utility.serializeDate(millis + offset);
}
/**
* Serialize midnight date value to general date text with time zone offset. Date values are formatted in W3C XML
* Schema standard format as CCYY-MM-DD, with optional leading sign included if necessary and trailing time zone
* offset.
*
* @param date date to be converted
* @return converted date text
*/
public static String serializeZonedDateMidnight(DateMidnight date) {
// get base time and offset
long millis = date.getMillis();
int offset = date.getZone().getOffset(millis);
// start serialization with the year, month, and day
StringBuffer buff = new StringBuffer(25);
Utility.formatYearMonthDay((millis + offset) + Utility.TIME_BASE, buff);
// finish with time zone offset
Utility.serializeOffset(offset, buff);
return buff.toString();
}
/**
* Serialize midnight date value to general date text with UTC time zone. Date values are formatted in W3C XML
* Schema standard format as CCYY-MM-DDZ, with optional leading sign included if necessary.
*
* @param date date to be converted
* @return converted date text
*/
public static String serializeUTCDateMidnight(DateMidnight date) {
// get base time and offset
long millis = date.getMillis();
int offset = date.getZone().getOffset(millis);
// start serialization with the year, month, and day
StringBuffer buff = new StringBuffer(25);
Utility.formatYearMonthDay((millis + offset) + Utility.TIME_BASE, buff);
// finish with time zone offset
buff.append('Z');
return buff.toString();
}
/**
* Deserialize time value from text as local time. Time values are expected to match W3C XML Schema standard format
* as hh:mm:ss.fff, with optional trailing time zone (with the time zone ignored in this case). This method follows
* standard JiBX deserializer usage requirements by accepting a null input.
*
* @param text text to be parsed (may be null)
* @return converted date, or null if passed null input
* @throws JiBXException on parse error
*/
public static LocalTime deserializeLocalTime(String text) throws JiBXException {
if (text == null) {
return null;
} else {
return new LocalTime(Utility.parseTimeNoOffset(text, 0, text.length()), DateTimeZone.UTC);
}
}
/**
* Serialize local time value to general date text without time zone. Time values are formatted in W3C XML Schema
* standard format as hh:mm:ss.fff.
*
* @param time time to be converted
* @return converted time text
*/
public static String serializeUnzonedLocalTime(LocalTime time) {
StringBuffer buff = new StringBuffer(12);
Utility.serializeTime(time.getMillisOfDay(), buff);
return buff.toString();
}
/**
* Serialize local time value to general date text with UTC time zone. Time values are formatted in W3C XML Schema
* standard format as hh:mm:ss.fffZ, with optional leading sign included if necessary.
*
* @param time time to be converted
* @return converted time text
*/
public static String serializeUTCLocalTime(LocalTime time) {
StringBuffer buff = new StringBuffer(13);
Utility.serializeTime(time.getMillisOfDay(), buff);
buff.append('Z');
return buff.toString();
}
/**
* Parse date/time value from text. Date values are expected to match W3C XML Schema standard format as
* CCYY-MM-DDThh:mm:ss.fff, with optional leading sign and trailing time zone (with the time zone used to convert
* the value to the target time zone). If the time zone is absent and not required the target time zone is assumed.
*
* @param text
* @param full zoned time required flag (exception thrown if missing)
* @param zone time zone used for returned date/time
* @return converted date/time
* @throws JiBXException
*/
protected static DateTime parseDateTime(String text, boolean full, DateTimeZone zone) throws JiBXException {
// split text to convert portions separately
int split = text.indexOf('T');
if (split < 0) {
throw new JiBXException("Missing 'T' separator in dateTime");
}
int length = text.length();
long milli = Utility.parseDate(text.substring(0, split)) +
Utility.parseTimeNoOffset(text, split+1, length);
// check for time zone offset specified
int start = split + 9;
boolean utc = false;
if (length > start) {
// adjust for time zone
utc = true;
if (text.charAt(length-1) != 'Z') {
char chr = text.charAt(length-6);
if (chr == '-' || chr == '+') {
int hour = Utility.parseDigits(text, length-5, 2);
int minute = Utility.parseDigits(text, length-2, 2);
if (hour > 14 || minute > 59 || (hour == 14 && minute != 0)) {
throw new JiBXException("Invalid time zone offset: " + text);
} else {
int offset = ((hour*60)+minute)*60*1000;
if (chr == '-') {
milli += offset;
} else {
milli -= offset;
}
}
}
}
} else if (full) {
throw new JiBXException("Missing required time zone offset: " + text);
}
// convert to target time zone
if (!utc) {
milli -= zone.getOffset(milli);
}
return new DateTime(milli, zone);
}
/**
* Deserialize date/time value from text in specified (or default) time zone. Date/time values are expected to match
* W3C XML Schema standard format as CCYY-MM-DDThh:mm:ss.fff, with optional leading sign and trailing time zone. If
* the time zone indication is included a zone matching the offset is used for the date; otherwise the default time
* zone is used. This method follows standard JiBX deserializer usage requirements by accepting a null
* input.
*
* @param text text to be parsed (may be null)
* @return converted date, or null if passed null input
* @throws JiBXException on parse error
*/
public static DateTime deserializeZonedDateTime(String text) throws JiBXException {
if (text == null) {
return null;
} else {
DateTimeZone zone = findZone(text, DateTimeZone.getDefault());
return parseDateTime(text, false, zone);
}
}
/**
* Deserialize UTC date/time value from text into the UTC time zone. Date values are expected to match W3C XML
* Schema standard format as CCYY-MM-DDThh:mm:ss.fff, with optional leading sign and trailing time zone (with the
* time zone used to convert the value to UTC, and UTC assumed if no time zone is specified). This method follows
* standard JiBX deserializer usage requirements by accepting a null input.
*
* @param text text to be parsed (may be null)
* @return converted date, or null if passed null input
* @throws JiBXException on parse error
*/
public static DateTime deserializeUTCDateTime(String text) throws JiBXException {
if (text == null) {
return null;
} else {
return new DateTime(Utility.parseDateTime(text), DateTimeZone.UTC);
}
}
/**
* Deserialize date/time value from text into the local (default) time zone. Date values are expected to match W3C
* XML Schema standard format as CCYY-MM-DDThh:mm:ss.fff, with optional leading sign and trailing time zone (with
* the time zone used to convert the value to the local time zone, and the local time zone assumed if no time zone
* is specified). This method follows standard JiBX deserializer usage requirements by accepting a null
* input.
*
* @param text text to be parsed (may be null)
* @return converted date, or null if passed null input
* @throws JiBXException on parse error
*/
public static DateTime deserializeLocalDateTime(String text) throws JiBXException {
if (text == null) {
return null;
} else {
return parseDateTime(text, false, DateTimeZone.getDefault());
}
}
/**
* Deserialize UTC date/time value from text with time zone required. Date values are expected to match W3C XML
* Schema standard format as CCYY-MM-DDThh:mm:ss.fff, with optional leading sign but required trailing time zone
* (with the time zone used to convert the value to UTC). This method follows standard JiBX deserializer usage
* requirements by accepting a null input.
*
* @param text text to be parsed (may be null)
* @return converted date, or null if passed null input
* @throws JiBXException on parse error
*/
public static DateTime deserializeStrictUTCDateTime(String text) throws JiBXException {
if (text == null) {
return null;
} else {
return parseDateTime(text, true, DateTimeZone.UTC);
}
}
/**
* Deserialize local (default zone) date/time value from text with time zone required. Date values are expected to
* match W3C XML Schema standard format as CCYY-MM-DDThh:mm:ss.fff, with optional leading sign but required trailing
* time zone (with the time zone used to convert the value to the local time zone). This method follows standard
* JiBX deserializer usage requirements by accepting a null input.
*
* @param text text to be parsed (may be null)
* @return converted date, or null if passed null input
* @throws JiBXException on parse error
*/
public static DateTime deserializeStrictLocalDateTime(String text) throws JiBXException {
if (text == null) {
return null;
} else {
return parseDateTime(text, true, DateTimeZone.getDefault());
}
}
/**
* Serialize date/time to general dateTime text. Date/time values are formatted in W3C XML Schema standard format as
* CCYY-MM-DDThh:mm:ss.fff, with optional leading sign included if necessary. Time zone information is always
* included in the output, with the value determined by the zone used for the date/time.
*
* @param time date/time to be converted
* @return converted date/time text
*/
public static String serializeZonedDateTime(DateTime time) {
// get offset and adjusted time value
int offset = time.getZone().getOffset(time.getMillis());
long msec = time.getMillis() + offset;
// start serialization with the year, month, and day
StringBuffer buff = new StringBuffer(25);
int extra = Utility.formatYearMonthDay(msec + Utility.TIME_BASE, buff);
// append the time for full form
buff.append('T');
Utility.serializeTime(extra, buff);
// finish with time zone offset
Utility.serializeOffset(offset, buff);
return buff.toString();
}
/**
* Serialize date/time to general dateTime text. Date/time values are formatted in W3C XML Schema standard format as
* CCYY-MM-DDThh:mm:ss.fff, with optional leading sign included if necessary. Time zone information is always
* included in the output, as 'Z' to indicate UTC.
*
* @param time date/time to be converted
* @return converted date/time text
*/
public static String serializeUTCDateTime(DateTime time) {
return Utility.serializeDateTime(time.getMillis(), true);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/EnumSet.java 0000644 0001750 0001750 00000024026 10524403562 023562 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import java.util.Arrays;
import java.util.Comparator;
/**
* Named value set support class. This provides convenience methods to support
* working with a set of named static final int values, including
* translating them to and from String representations. It's
* intended for use with relatively small nonnegative int values.
*
* @author Dennis M. Sosnoski
*/
public class EnumSet
{
/** Maximum int value supported for enumerations. */
public static final int VALUE_LIMIT = 512;
/** Actual item definitions (used for extensions). */
private final EnumItem[] m_items;
/** Enumeration names in index number order. */
private final String[] m_indexedNames;
/** Enumeration names in sort order. */
private final String[] m_orderedNames;
/** Index values corresponding to sorted names. */
private final int[] m_orderedIndexes;
/**
* Constructor from array of enumeration items. The supplied items can be in
* any order, and the numeric values do not need to be contiguous (but must
* be unique, nonnegative, and should be fairly small). Note that this
* constructor will reorder the items in the supplied array as a side
* effect.
*
* @param items array of enumeration items (will be reordered)
*/
public EnumSet(EnumItem[] items) {
m_items = items;
if (items.length > 0) {
// first sort items in ascending name order
Arrays.sort(items, new Comparator() {
public int compare(Object a, Object b) {
return ((EnumItem)a).m_name.compareTo(((EnumItem)b).m_name);
}
});
// populate arrays for name lookup
m_orderedNames = new String[items.length];
m_orderedIndexes = new int[items.length];
int high = -1;
for (int i = 0; i < items.length; i++) {
EnumItem item = items[i];
if (item.m_value < 0) {
throw new IllegalArgumentException("Negative item value " +
item.m_value + " not allowed");
} else if (item.m_value > high) {
high = item.m_value;
if (high >= VALUE_LIMIT) {
throw new IllegalArgumentException
("Enumeration with value " +
high + " too large to be used.");
}
}
m_orderedNames[i] = item.m_name;
m_orderedIndexes[i] = item.m_value;
}
// populate array for indexed lookup of names
m_indexedNames = new String[high+1];
for (int i = 0; i < items.length; i++) {
EnumItem item = items[i];
if (m_indexedNames[item.m_value] == null) {
m_indexedNames[item.m_value] = item.m_name;
} else {
throw new IllegalArgumentException
("Duplicate index value " + item.m_value);
}
}
} else {
m_indexedNames = new String[0];
m_orderedNames = new String[0];
m_orderedIndexes = new int[0];
}
}
/**
* Constructor from array of names. The value associated with each name is
* just the position index in the array added to the start value.
*
* @param start item value for first added name
* @param names array of names (no null entries allowed)
*/
public EnumSet(int start, String[] names) {
this(buildItems(start, names));
}
/**
* Constructor from existing enumeration with added names. The value
* associated with each name is just the position index in the array added
* to the start value.
*
* @param base base enumeration to be extended
* @param start item value for first added name
* @param names array of names (no null entries allowed)
*/
public EnumSet(EnumSet base, int start, String[] names) {
this(mergeItems(base, start, names));
}
/**
* Generate array of enumeration items from array of names. The value
* associated with each name is just the position index in the array added
* to the start value.
*
* @param start item value for first added name
* @param names array of names (no null entries allowed)
*/
private static EnumItem[] buildItems(int start, String[] names) {
EnumItem[] items = new EnumItem[names.length];
for (int i = 0; i < items.length; i++) {
items[i] = new EnumItem(start+i, names[i]);
}
return items;
}
/**
* Generate array of enumeration items from base enumeration and array of
* names. The value associated with each name is just the position index in
* the array added to the start value.
*
* @param base base enumeration to be extended
* @param start item value for first added name
* @param names array of names (no null entries allowed)
*/
private static EnumItem[] mergeItems(EnumSet base, int start,
String[] names) {
int prior = base.m_items.length;
EnumItem[] merges = new EnumItem[prior + names.length];
System.arraycopy(base.m_items, 0, merges, 0, prior);
for (int i = 0; i < names.length; i++) {
merges[prior+i] = new EnumItem(start+i, names[i]);
}
return merges;
}
/**
* Get name for value if defined.
*
* @param value enumeration value
* @return name for value, or null if not defined
*/
public String getName(int value) {
if (value >= 0 && value < m_indexedNames.length) {
return m_indexedNames[value];
} else {
return null;
}
}
/**
* Get name for value. If the supplied value is not defined in the
* enumeration this throws an exception.
*
* @param value enumeration value
* @return name for value
*/
public String getNameChecked(int value) {
if (value >= 0 && value < m_indexedNames.length) {
String name = m_indexedNames[value];
if (name != null) {
return name;
}
}
throw new IllegalArgumentException("Value " + value + " not defined");
}
/**
* Get value for name if defined.
*
* @param name possible enumeration name
* @return value for name, or -1 if not found in enumeration
*/
public int getValue(String name) {
int base = 0;
int limit = m_orderedNames.length - 1;
while (base <= limit) {
int cur = (base + limit) >> 1;
int diff = name.compareTo(m_orderedNames[cur]);
if (diff < 0) {
limit = cur - 1;
} else if (diff > 0) {
base = cur + 1;
} else if (m_orderedIndexes != null) {
return m_orderedIndexes[cur];
} else {
return cur;
}
}
return -1;
}
/**
* Get value for name. If the supplied name is not present in the
* enumeration this throws an exception.
*
* @param name enumeration name
* @return value for name
*/
public int getValueChecked(String name) {
int index = getValue(name);
if (index >= 0) {
return index;
} else {
throw new IllegalArgumentException("Name " + name + " not defined");
}
}
/**
* Check value with exception. Throws an exception if the supplied value is
* not defined by this enumeration.
*
* @param value
*/
public void checkValue(int value) {
if (value < 0 || value >= m_indexedNames.length ||
m_indexedNames[value] == null) {
throw new IllegalArgumentException("Value " + value +
" not defined");
}
}
/**
* Get maximum index value in enumeration set.
*
* @return maximum
*/
public int maxIndex() {
return m_indexedNames.length - 1;
}
/**
* Enumeration pair information. This gives an int value along
* with the associated String representation.
*/
public static class EnumItem {
public final int m_value;
public final String m_name;
public EnumItem(int value, String name) {
m_value = value;
m_name = name;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/IExtensibleWriter.java 0000644 0001750 0001750 00000004221 10737003370 025604 0 ustar twerner twerner /*
Copyright (c) 2007, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import java.io.IOException;
/**
* Extensible version of standard XML writer interface. This allows the creation
* of child writer instances with added namespaces.
*
* @author Dennis M. Sosnoski
*/
public interface IExtensibleWriter extends IXMLWriter
{
/**
* Create a child writer instance to be used for a separate binding. The
* child writer inherits the output handling from this writer, while using
* the supplied namespace URIs.
*
* @param uris ordered array of URIs for namespaces used in document
* @return child writer
* @throws IOException
*/
IXMLWriter createChildWriter(String[] uris) throws IOException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/package.html 0000644 0001750 0001750 00000000327 10071714366 023622 0 ustar twerner twerner
User interface to JiBX data binding framework runtime. These are the classes and interfaces
generally intended for direct use by end users, and are considered published APIs
which will remain stable.
libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/IUnmarshallable.java 0000644 0001750 0001750 00000004716 11043445700 025246 0 ustar twerner twerner /*
Copyright (c) 2002-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
/**
* Unmarshallable interface definition. This interface must be implemented by
* all classes which can be unmarshalled as independent units (not just as
* children of other objects). Classes implementing this interface may either
* unmarshal themselves directly (if there's only one unmarshalling format
* defined), or obtain an instance of the appropriate unmarshaller from the
* context and use that.
*
* @author Dennis M. Sosnoski
*/
public interface IUnmarshallable
{
/**
* Get the name of the class associated with the <mapping> definition.
*
* @return fully-qualified class name
*/
String JiBX_className();
/**
* Unmarshal self. This method call is responsible for all handling of the
* unmarshalling of the object from XML text.
*
* @param ctx unmarshalling context
* @throws JiBXException on error in unmarshalling process
*/
void unmarshal(IUnmarshallingContext ctx) throws JiBXException;
}
libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/IMarshallable.java 0000644 0001750 0001750 00000005115 11151766426 024710 0 ustar twerner twerner /*
Copyright (c) 2002-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
/**
* Marshallable interface definition. This interface must be implemented by all
* classes which can be marshalled as independent units (not just as children of
* other objects). Classes implementing this interface may either marshal
* themselves directly (if there's only one marshalling format defined), or
* obtain an instance of the appropriate marshaller from the context and use
* that. This interface is automatically added by the binding compiler to all
* classes targeted by <mapping> elements in a binding.
*
* @author Dennis M. Sosnoski
*/
public interface IMarshallable
{
/**
* Get the name of the class or type associated with the <mapping>
* definition.
*
* @return fully-qualified class name, or type name
*/
String JiBX_getName();
/**
* Marshal self. This method call is responsible for all handling of the
* marshalling of an object to XML text.
*
* @param ctx marshalling context
* @throws JiBXException on error in marshalling process
*/
void marshal(IMarshallingContext ctx) throws JiBXException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/IntStack.java 0000644 0001750 0001750 00000023135 10434260716 023724 0 ustar twerner twerner /*
Copyright (c) 2000-2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import java.lang.reflect.Array;
/**
* Growable int stack with type specific access methods. This
* implementation is unsynchronized in order to provide the best possible
* performance for typical usage scenarios, so explicit synchronization must
* be implemented by a wrapper class or directly by the application in cases
* where instances are modified in a multithreaded environment. See the base
* classes for other details of the implementation.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class IntStack
{
/** Default initial array size. */
public static final int DEFAULT_SIZE = 8;
/** Size of the current array. */
protected int m_countLimit;
/** The number of values currently present in the stack. */
protected int m_countPresent;
/** Maximum size increment for growing array. */
protected int m_maximumGrowth;
/** The underlying array used for storing the data. */
protected int[] m_baseArray;
/**
* Constructor with full specification.
*
* @param size number of int values initially allowed in
* stack
* @param growth maximum size increment for growing stack
*/
public IntStack(int size, int growth) {
m_countLimit = size;
m_maximumGrowth = growth;
m_baseArray = new int[size];
}
/**
* Constructor with initial size specified.
*
* @param size number of int values initially allowed in
* stack
*/
public IntStack(int size) {
this(size, Integer.MAX_VALUE);
}
/**
* Default constructor.
*/
public IntStack() {
this(DEFAULT_SIZE);
}
/**
* Copy (clone) constructor.
*
* @param base instance being copied
*/
public IntStack(IntStack base) {
this(base.m_countLimit, base.m_maximumGrowth);
System.arraycopy(base.m_baseArray, 0, m_baseArray, 0,
base.m_countPresent);
m_countPresent = base.m_countPresent;
}
/**
* Constructor from array of ints.
*
* @param ints array of ints for initial contents
*/
public IntStack(int[] ints) {
this(ints.length);
System.arraycopy(ints, 0, m_baseArray, 0, ints.length);
m_countPresent = ints.length;
}
/**
* Copy data after array resize. This just copies the entire contents of the
* old array to the start of the new array. It should be overridden in cases
* where data needs to be rearranged in the array after a resize.
*
* @param base original array containing data
* @param grown resized array for data
*/
private void resizeCopy(Object base, Object grown) {
System.arraycopy(base, 0, grown, 0, Array.getLength(base));
}
/**
* Increase the size of the array to at least a specified size. The array
* will normally be at least doubled in size, but if a maximum size
* increment was specified in the constructor and the value is less than
* the current size of the array, the maximum increment will be used
* instead. If the requested size requires more than the default growth,
* the requested size overrides the normal growth and determines the size
* of the replacement array.
*
* @param required new minimum size required
*/
private void growArray(int required) {
int size = Math.max(required,
m_countLimit + Math.min(m_countLimit, m_maximumGrowth));
int[] grown = new int[size];
resizeCopy(m_baseArray, grown);
m_countLimit = size;
m_baseArray = grown;
}
/**
* Ensure that the array has the capacity for at least the specified
* number of values.
*
* @param min minimum capacity to be guaranteed
*/
public final void ensureCapacity(int min) {
if (min > m_countLimit) {
growArray(min);
}
}
/**
* Push a value on the stack.
*
* @param value value to be added
*/
public void push(int value) {
int index = getAddIndex();
m_baseArray[index] = value;
}
/**
* Pop a value from the stack.
*
* @return value from top of stack
* @exception ArrayIndexOutOfBoundsException on attempt to pop empty stack
*/
public int pop() {
if (m_countPresent > 0) {
return m_baseArray[--m_countPresent];
} else {
throw new ArrayIndexOutOfBoundsException
("Attempt to pop empty stack");
}
}
/**
* Pop multiple values from the stack. The last value popped is the
* one returned.
*
* @param count number of values to pop from stack (must be strictly
* positive)
* @return value from top of stack
* @exception ArrayIndexOutOfBoundsException on attempt to pop past end of
* stack
*/
public int pop(int count) {
if (count <= 0) {
throw new IllegalArgumentException("Count must be greater than 0");
} else if (m_countPresent >= count) {
m_countPresent -= count;
return m_baseArray[m_countPresent];
} else {
throw new ArrayIndexOutOfBoundsException
("Attempt to pop past end of stack");
}
}
/**
* Copy a value from the stack. This returns a value from within
* the stack without modifying the stack.
*
* @param depth depth of value to be returned
* @return value from stack
* @exception ArrayIndexOutOfBoundsException on attempt to peek past end of
* stack
*/
public int peek(int depth) {
if (m_countPresent > depth) {
return m_baseArray[m_countPresent - depth - 1];
} else {
throw new ArrayIndexOutOfBoundsException
("Attempt to peek past end of stack");
}
}
/**
* Copy top value from the stack. This returns the top value without
* removing it from the stack.
*
* @return value at top of stack
* @exception ArrayIndexOutOfBoundsException on attempt to peek empty stack
*/
public int peek() {
return peek(0);
}
/**
* Constructs and returns a simple array containing the same data as held
* in this stack. Note that the items will be in reverse pop order, with
* the last item to be popped from the stack as the first item in the
* array.
*
* @return array containing a copy of the data
*/
public int[] toArray() {
int[] copy = new int[m_countPresent];
System.arraycopy(m_baseArray, 0, copy, 0, m_countPresent);
return copy;
}
/**
* Duplicates the object with the generic call.
*
* @return a copy of the object
*/
public Object clone() {
return new IntStack(this);
}
/**
* Gets the array offset for appending a value to those in the stack.
* If the underlying array is full, it is grown by the appropriate size
* increment so that the index value returned is always valid for the
* array in use by the time of the return.
*
* @return index position for added element
*/
private int getAddIndex() {
int index = m_countPresent++;
if (m_countPresent > m_countLimit) {
growArray(m_countPresent);
}
return index;
}
/**
* Get the number of values currently present in the stack.
*
* @return count of values present
*/
public int size() {
return m_countPresent;
}
/**
* Check if stack is empty.
*
* @return true if stack empty, false if not
*/
public boolean isEmpty() {
return m_countPresent == 0;
}
/**
* Set the stack to the empty state.
*/
public void clear() {
m_countPresent = 0;
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/JiBXException.java 0000644 0001750 0001750 00000007616 11155511334 024661 0 ustar twerner twerner /*
Copyright (c) 2002-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import java.io.PrintStream;
import java.io.PrintWriter;
/**
* Binding exception class. This is used for all types of errors that
* can be generated by the runtime.
*
* @author Dennis M. Sosnoski
*/
public class JiBXException extends Exception
{
/** Exception that caused this exception. */
private Throwable m_rootCause;
/**
* Constructor from message.
*
* @param msg message describing the exception condition
*/
public JiBXException(String msg) {
super(msg);
}
/**
* Constructor from message and wrapped exception.
*
* @param msg message describing the exception condition
* @param root exception which caused this exception
*/
public JiBXException(String msg, Throwable root) {
super(msg);
m_rootCause = root;
}
/**
* Get root cause exception.
*
* @return exception that caused this exception
*/
public Throwable getRootCause() {
return m_rootCause;
}
/**
* Get the cause of this exception. Provided for compatibility with later
* JVMs, overriding the java.lang.Throwable method.
*
* @return exception that caused this exception
*/
public Throwable getCause() {
return getRootCause();
}
/**
* Print stack trace to standard error. This is an override of the base
* class method to implement exception chaining.
*/
public void printStackTrace() {
printStackTrace(System.err);
}
/**
* Print stack trace to stream. This is an override of the base class method
* to implement exception chaining.
*
* @param s stream for printing stack trace
*/
public void printStackTrace(PrintStream s) {
if (m_rootCause == null) {
super.printStackTrace(s);
} else {
s.println(getMessage());
m_rootCause.printStackTrace(s);
s.println();
}
}
/**
* Print stack trace to writer. This is an override of the base class method
* to implement exception chaining.
*
* @param s writer for printing stack trace
*/
public void printStackTrace(PrintWriter s) {
if (m_rootCause == null) {
super.printStackTrace(s);
} else {
s.println(getMessage());
m_rootCause.printStackTrace(s);
s.println();
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/JiBXParseException.java 0000644 0001750 0001750 00000011007 11003053146 025633 0 ustar twerner twerner /*
Copyright (c) 2008, Joshua Davies.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
/**
* JiBX parsing exception class. This subclass of JiBXException provides
* additional details when a parsing error occurs such as what tag was
* being parsed and what value caused the error.
*
* @author Joshua Davies
*/
public class JiBXParseException extends JiBXException
{
private String m_value;
private String m_namespace;
private String m_tagName;
/**
* Constructor from message.
* @param msg the throwers description of what's gone wrong.
* @param value the value which was unparseable (in string format).
*/
public JiBXParseException(String msg, String value) {
super(msg);
m_value = value;
}
/**
* Constructor from message and wrapped exception.
* @param msg the throwers description of what's gone wrong.
* @param value the value which was unparseable (in string format).
* @param root exception which caused this exception
*/
public JiBXParseException(String msg, String value, Throwable root) {
super(msg, root);
m_value = value;
}
/**
* Constructor from message, wrapped exception and tag name.
*
* @param msg message describing the exception condition
* @param value the value which was unparseable (in string format).
* @param namespace the namespace (if any) associated with the tag.
* @param tagName the name of the tag whose element caused the exception.
* @param root exception which caused this exception
*/
public JiBXParseException(String msg, String value, String namespace, String tagName, Throwable root) {
super(msg, root);
m_value = value;
m_namespace = namespace;
m_tagName = tagName;
}
/**
* Add namespace detail to the exception.
* @param namespace the namespace of the offending tag.
*/
public void setNamespace(String namespace) {
m_namespace = namespace;
}
/**
* Add tag name detail to the exception.
* @param tagName the name of the offending tag.
*/
public void setTagName(String tagName) {
m_tagName = tagName;
}
/**
* Append useful parsing details onto the default message.
* @return the parent's message plus "caused by value" addendum.
*/
public String getMessage() {
return super.getMessage() + ", caused by value '" + m_value + "' for tag '" +
( m_namespace == null ? "" : m_namespace + ":" ) + m_tagName + "'";
}
/**
* This is only used for testing purposes.
* @param obj what to compare against.
* @return true or false
*/
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final JiBXParseException other = (JiBXParseException) obj;
if (m_namespace == null) {
if (other.m_namespace != null)
return false;
} else if (!m_namespace.equals(other.m_namespace))
return false;
if (m_tagName == null) {
if (other.m_tagName != null)
return false;
} else if (!m_tagName.equals(other.m_tagName))
return false;
if (m_value == null) {
if (other.m_value != null)
return false;
} else if (!m_value.equals(other.m_value))
return false;
return true;
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/QName.java 0000644 0001750 0001750 00000030672 11414040252 023177 0 ustar twerner twerner /*
Copyright (c) 2005-2010, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import java.util.ArrayList;
import org.jibx.runtime.impl.MarshallingContext;
import org.jibx.runtime.impl.UnmarshallingContext;
/**
* Representation of a qualified name. This includes the JiBX
* serializer/deserializer methods for the representation. It assumes that the
* actual namespace declarations are being handled separately for
* marshalling
*
* Note that this implementation treats only the namespace and local name as
* significant for purposes of comparing values. The prefix is held only as a
* convenience, and the actual prefix used when writing a value may differ from
* the prefix defined by the instance.
*
* @author Dennis M. Sosnoski
*/
public class QName
{
/** Namespace URI. */
private String m_uri;
/** Namespace prefix. */
private String m_prefix;
/** Local name. */
private String m_name;
/**
* Constructor from full set of components.
*
* @param uri namespace uri, null if no-namespace namespace
* @param prefix namespace prefix, null if unspecified, empty
* string if default namespace
* @param name local name
*/
public QName(String uri, String prefix, String name) {
m_uri = uri;
m_prefix = prefix;
m_name = name;
}
/**
* Constructor from namespace and local name. This constructor is provided
* as a convenience for when the actual prefix used for a namespace is
* irrelevant.
*
* @param uri namespace uri, null if no-namespace namespace
* @param name
*/
public QName(String uri, String name) {
this(uri, null, name);
}
/**
* Constructor from local name only. This constructor is provided as a
* convenience for names in the no-namespace namespace.
*
* @param name
*/
public QName(String name) {
this(null, null, name);
}
//
// Overrides of base class methods
/* (non-Javadoc)
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
if (obj instanceof QName) {
QName qname = (QName)obj;
if (m_name.equals(qname.getName())) {
if (m_uri == null) {
return qname.getUri() == null;
} else {
return m_uri.equals(qname.getUri());
}
}
}
return false;
}
/* (non-Javadoc)
* @see java.lang.Object#hashCode()
*/
public int hashCode() {
return (m_uri == null ? 0 : m_uri.hashCode()) + m_name.hashCode();
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
public String toString() {
if (m_uri == null) {
return m_name;
} else {
return "{" + m_uri + "}:" + m_name;
}
}
//
// Access methods
/**
* Get local name.
*
* @return name
*/
public String getName() {
return m_name;
}
/**
* Set local name.
*
* @param name name
*/
public void setName(String name) {
m_name = name;
}
/**
* Get namespace prefix.
*
* @return prefix, null if unspecified, empty string if default
* namespace
*/
public String getPrefix() {
return m_prefix;
}
/**
* Set namespace prefix.
*
* @param prefix prefix, null if unspecified, empty string if
* default namespace
*/
public void setPrefix(String prefix) {
m_prefix = prefix;
}
/**
* Get namespace URI.
*
* @return uri namespace uri, null if no-namespace namespace
*/
public String getUri() {
return m_uri;
}
/**
* Set namespace URI.
*
* @param uri namespace uri, null if no-namespace namespace
*/
public void setUri(String uri) {
m_uri = uri;
}
//
// JiBX conversion methods
/**
* JiBX deserializer method. This is intended for use as a deserializer for
* instances of the class.
*
* @param text value text
* @param ictx unmarshalling context
* @return created class instance
* @throws JiBXException on error in unmarshalling
*/
public static QName deserialize(String text, IUnmarshallingContext ictx)
throws JiBXException {
if (text == null) {
return null;
} else {
// check for prefix used in text representation
int split = text.indexOf(':');
if (split > 0) {
// strip off prefix
String prefix = text.substring(0, split);
text = text.substring(split+1);
// look up the namespace URI associated with the prefix
String uri =
((UnmarshallingContext)ictx).getNamespaceUri(prefix);
if (uri == null) {
throw new JiBXException("Undefined prefix " + prefix);
} else {
// create an instance of class to hold all components
return new QName(uri, prefix, text);
}
} else {
// create it using the default namespace URI
String uri = ((UnmarshallingContext)ictx).getNamespaceUri(null);
if (uri != null && uri.length() == 0) {
uri = null;
}
return new QName(uri, "", text);
}
}
}
/**
* JiBX serializer method. This is intended for use as a serializer for
* instances of the class. The namespace must be active in the output
* document at the point where this is called.
*
* @param qname value to be serialized
* @param ictx unmarshalling context
* @return created class instance
* @throws JiBXException on error in marshalling
*/
public static String serialize(QName qname, IMarshallingContext ictx)
throws JiBXException {
if (qname == null) {
return null;
} else {
// check for specified prefix
IXMLWriter ixw = ((MarshallingContext)ictx).getXmlWriter();
int index = -1;
String uri = qname.getUri();
if (uri == null) {
uri = "";
}
if (qname.getPrefix() != null) {
// see if prefix already defined in document with correct URI
int tryidx = ixw.getPrefixIndex(qname.getPrefix());
if (tryidx >= 0 &&
uri.equals(ixw.getNamespaceUri(tryidx))) {
index = tryidx;
}
}
// check if need to lookup prefix for namespace
if (index < 0) {
// prefix not defined, find the namespace index in binding
if (uri == null) {
uri = "";
}
String[] nss = ixw.getNamespaces();
for (int i = 0; i < nss.length; i++) {
if (nss[i].equals(uri)) {
index = i;
break;
}
}
if (index < 0) {
// namespace not in binding, check extensions
String[][] nsss = ixw.getExtensionNamespaces();
if (nsss != null) {
int base = nss.length;
outer: for (int i = nsss.length-1; i >= 0; i--) {
nss = nsss[i];
for (int j = 0; j < nss.length; j++) {
if (nss[j].equals(uri)) {
// adjust for other extension namespaces
index = base + j;
for (int k = 0; k < i; k++) {
index += nsss[k].length;
}
break outer;
}
}
}
}
}
}
// check if prefix is already defined in document with correct URI
if (index >= 0) {
// get prefix defined for namespace
String prefix = ixw.getNamespacePrefix(index);
if (prefix == null) {
throw new JiBXException("Namespace URI " + qname.getUri() +
" cannot be used since it is not active");
} else if (prefix.length() > 0) {
return prefix + ':' + qname.getName();
} else {
return qname.getName();
}
} else {
throw new JiBXException("Unknown namespace URI " + qname.m_uri);
}
}
}
/**
* JiBX deserializer method. This is intended for use as a deserializer for
* a list made up of instances of the class.
*
* @param text value text
* @param ictx unmarshalling context
* @return array of instances
* @throws JiBXException on error in marshalling
*/
public static QName[] deserializeList(String text,
final IUnmarshallingContext ictx) throws JiBXException {
// use basic qualified name deserializer to handle items
IListItemDeserializer ldser = new IListItemDeserializer() {
public Object deserialize(String text) throws JiBXException {
return QName.deserialize(text, ictx);
}
};
ArrayList list = Utility.deserializeList(text, ldser);
if (list == null) {
return null;
} else {
return (QName[])list.toArray(new QName[list.size()]);
}
}
/**
* JiBX serializer method. This is intended for use as a serializer for a
* list made up of instances of the class. The namespace must be active in
* the output document at the point where this is called.
*
* @param qnames array of names to be serialized
* @param ictx unmarshalling context
* @return generated text
* @throws JiBXException on error in marshalling
*/
public static String serializeList(QName[] qnames, IMarshallingContext ictx)
throws JiBXException {
StringBuffer buff = new StringBuffer();
for (int i = 0; i < qnames.length; i++) {
QName qname = qnames[i];
if (qname != null) {
if (buff.length() > 0) {
buff.append(' ');
}
buff.append(serialize(qname, ictx));
}
}
return buff.toString();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/ValidationException.java 0000644 0001750 0001750 00000012326 10611641774 026161 0 ustar twerner twerner /*
Copyright (c) 2002-2007, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
/**
* Validation exception class. This is used for marshalling and unmarshalling
* errors that relate to data content.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class ValidationException extends RecoverableException
{
/**
* Constructor from message.
*
* @param msg message describing the exception condition
*/
public ValidationException(String msg) {
super(msg);
}
/**
* Constructor from message and wrapped exception.
*
* @param msg message describing the exception condition
* @param root exception which caused this exception
*/
public ValidationException(String msg, Throwable root) {
super(msg, root);
}
/**
* Constructor from message and validation object.
*
* @param msg message describing the exception condition
* @param obj source object for validation error
*/
public ValidationException(String msg, Object obj) {
super(addDescription(msg, obj));
}
/**
* Constructor from message, wrapped exception, and validation object.
*
* @param msg message describing the exception condition
* @param root exception which caused this exception
* @param obj source object for validation error
*/
public ValidationException(String msg, Throwable root, Object obj) {
super(addDescription(msg, obj), root);
}
/**
* Constructor from message, validation object, and unmarshalling context.
*
* @param msg message describing the exception condition
* @param obj source object for validation error
* @param ctx context used for unmarshalling
*/
public ValidationException(String msg, Object obj,
IUnmarshallingContext ctx) {
super(addDescription(msg, obj));
}
/**
* Get description information for a validation object. For an unmarshalled
* object with source references available this returns the source position
* description. Otherwise, it returns the result of a {@link
* java.lang.Object#toString} method call.
*
* @param obj source object for validation error
* @return object description text
*/
public static String describe(Object obj) {
if (obj instanceof ITrackSource) {
ITrackSource track = (ITrackSource)obj;
if (track.jibx_getColumnNumber() != 0 || track.jibx_getLineNumber() != 0 || track.jibx_getDocumentName() != null) {
StringBuffer text = new StringBuffer();
text.append("(line ");
text.append(track.jibx_getLineNumber());
text.append(", col ");
text.append(track.jibx_getColumnNumber());
if (track.jibx_getDocumentName() != null) {
text.append(", in ");
text.append(track.jibx_getDocumentName());
}
text.append(')');
return text.toString();
}
}
return "(source unknown)";
}
/**
* Add description information for a validation object to message. This just
* appends the result of a {@link #describe} call to the supplied message,
* with some appropriate formatting.
*
* @param msg base message text
* @param obj source object for validation error
* @return message with object description appended
*/
public static String addDescription(String msg, Object obj) {
return msg + " (" + describe(obj) + ")";
}
/**
* Get exception description.
*
* @return message describing the exception condition
*/
public String getMessage() {
return super.getMessage();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/ICharacterEscaper.java 0000644 0001750 0001750 00000005742 10071714354 025517 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import java.io.IOException;
import java.io.Writer;
/**
* Escaper for character data to be written to output document. This allows
* special character encodings to be handled appropriately on output. It's used
* by the generic output handler class during document marshalling.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public interface ICharacterEscaper
{
/**
* Write attribute value with character entity substitutions. This assumes
* that attributes use the regular quote ('"') delimitor.
*
* @param text attribute value text
* @param writer sink for output text
* @throws IOException on error writing to document
*/
public void writeAttribute(String text, Writer writer) throws IOException;
/**
* Write content value with character entity substitutions.
*
* @param text content value text
* @param writer sink for output text
* @throws IOException on error writing to document
*/
public void writeContent(String text, Writer writer) throws IOException;
/**
* Write CDATA to document. This writes the beginning and ending sequences
* for a CDATA section as well as the actual text, verifying that only
* characters allowed by the encoding are included in the text.
*
* @param text content value text
* @param writer sink for output text
* @throws IOException on error writing to document
*/
public void writeCData(String text, Writer writer) throws IOException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/Java5DecimalConvert.java 0000644 0001750 0001750 00000004370 11260360510 025761 0 ustar twerner twerner //#!j2me*
/*
Copyright (c) 2009, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import java.math.BigDecimal;
/**
* Utility class supplying a static method for java.math.BigDecimal serialization using Java 1.5 and later.
* Some idiot changed the toString() serialization format in Java 1.5, making it incompatible with the
* schema xs:decimal representation. This class acts as a bridge to the Java 1.5 API, and can only be used on Java 1.5
* and later (until Sun again changes the API) versions.
*
* @author Dennis M. Sosnoski
*/
public abstract class Java5DecimalConvert
{
/**
* Serialize decimal value to text using the
*
* @param value
* @return converted decimal text
*/
public static String serializeDecimal(BigDecimal value) {
return value.toPlainString();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/BindingDirectory.java 0000644 0001750 0001750 00000032126 11475012176 025444 0 ustar twerner twerner /*
Copyright (c) 2002-2008, Sosnoski Software Solutions, Inc.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* Abstract class with static methods to find the binding factory corresponding
* to a binding name.
*
* @author Dennis M. Sosnoski
*/
public abstract class BindingDirectory
{
/** Name of String[] field giving binding factory name list. */
public static final String BINDINGLIST_NAME = "JiBX_bindingList";
/** Prefix used in all code generation for methods and classes. */
public static final String GENERATE_PREFIX = "JiBX_";
/** Suffix of binding factory name. */
public static final String BINDINGFACTORY_SUFFIX = "Factory";
/** Binding factory method to get instance of factory. */
public static final String FACTORY_INSTMETHOD = "getInstance";
/** Empty argument list. */
public static final Class[] EMPTY_ARGS = new Class[0];
/**
* Get list of bindings for class. This just accesses the static variable
* added to each class with a top-level mapping.
*
* @param clas class with top-level mapping in binding
* @return list of bindings defined for that class (as a text string)
* @throws JiBXException on error accessing binding information
*/
private static String getBindingList(Class clas)throws JiBXException {
try {
Field field = clas.getDeclaredField(BINDINGLIST_NAME);
try {
// should be able to access field anyway, but just in case
field.setAccessible(true);
} catch (Exception e) { /* deliberately left empty */ }
return (String)field.get(null);
} catch (NoSuchFieldException e) {
throw new JiBXException
("Unable to access binding information for class " +
clas.getName() +
"\nMake sure the binding has been compiled", e);
} catch (IllegalAccessException e) {
throw new JiBXException
("Error in added code for class " + clas.getName() +
"Please report this to the JiBX developers", e);
}
}
/**
* Get instance of factory. Loads the factory class using the classloader
* for the supplied class, then calls the get instance method of the
* factory class.
*
* @param name fully qualified name of factory class
* @param clas class providing factory
* @param loader class loader to be used for loading factory
* @return binding factory instance
* @throws JiBXException on error loading or accessing factory
*/
private static IBindingFactory getFactoryFromName(String name, Class clas,
ClassLoader loader) throws JiBXException {
Throwable ex = null;
Object result = null;
IBindingFactory ifact = null;
boolean incompat = false;
try {
Class factory = loader.loadClass(name);
Method method = factory.getMethod(FACTORY_INSTMETHOD, EMPTY_ARGS);
result = method.invoke(null, (Object[])null);
} catch (SecurityException e) {
ex = e;
} catch (ClassNotFoundException e) {
ex = e;
} catch (NoSuchMethodException e) {
ex = e;
} catch (IllegalAccessException e) {
ex = e;
} catch (InvocationTargetException e) {
ex = e;
incompat = true;
} finally {
if (ex == null) {
if (result instanceof IBindingFactory) {
ifact = (IBindingFactory)result;
int diff = ifact.getCompilerVersion() ^
IBindingFactory.CURRENT_VERSION_NUMBER;
if ((diff & IBindingFactory.COMPATIBLE_VERSION_MASK) != 0) {
throw new JiBXException
("Binding information for class " + clas.getName() +
" must be recompiled with current binding " +
"compiler (compiled with " +
ifact.getCompilerDistribution() + ", runtime is " +
IBindingFactory.CURRENT_VERSION_NAME + ")");
} else {
ifact.verifyBaseBindings();
}
} else {
throw new JiBXException
("Classloader conflict for binding factory '" + name +
"' - factory does not implement required interface");
}
} else if (incompat) {
throw new JiBXException("Incompatible binding version for " +
"class " + clas.getName() +
", recompile binding with current JiBX distribution", ex);
} else {
throw new JiBXException
("Unable to access binding information for class " +
clas.getName() + "\nMake sure classes generated by the " +
"binding compiler are available at runtime", ex);
}
}
return ifact;
}
/**
* Get instance of binding factory. Finds the binding factory for the
* named binding on the target class, then loads that factory and returns
* an instance.
*
* @param name binding name
* @param clas target class for binding
* @param loader class loader to be used for loading factory
* @return binding factory instance
* @throws JiBXException on any error in finding or accessing factory
*/
public static IBindingFactory getFactory(String name, Class clas,
ClassLoader loader) throws JiBXException {
String list = getBindingList(clas);
String match = GENERATE_PREFIX + convertName(name) +
BINDINGFACTORY_SUFFIX + '|';
int index = list.indexOf(match);
if (index >= 0) {
int mark = list.lastIndexOf('|', index);
String fname =
list.substring(mark+1, index + match.length() - 1);
mark = fname.indexOf('=');
if (mark >= 0) {
fname = fname.substring(0, mark);
}
return getFactoryFromName(fname, clas, loader);
} else {
throw new JiBXException("Binding '" + name +
"' not found for class " + clas.getName());
}
}
/**
* Get instance of binding factory. Finds the binding factory for the
* named binding on the target class, then loads that factory and returns
* an instance.
*
* @param name binding name
* @param clas target class for binding
* @return binding factory instance
* @throws JiBXException on any error in finding or accessing factory
*/
public static IBindingFactory getFactory(String name, Class clas)
throws JiBXException {
return getFactory(name, clas, clas.getClassLoader());
}
/**
* Get instance of binding factory. Finds the binding factory for the
* target class, then loads that factory and returns an instance. This
* method can only be used with target classes that are mapped in only
* one binding.
*
* @param clas target class for binding
* @return binding factory instance
* @throws JiBXException on any error in finding or accessing factory
*/
public static IBindingFactory getFactory(Class clas) throws JiBXException {
String list = getBindingList(clas);
if (list != null && list.length() > 2) {
String fact = list.substring(1, list.length()-1);
if (fact.indexOf('|') < 0) {
return getFactoryFromName(fact, clas, clas.getClassLoader());
}
}
throw new JiBXException("Multiple bindings defined for class " +
clas.getName());
}
/**
* Get instance of binding factory. Finds the binding factory for the
* named binding on the target class, then loads that factory and returns
* an instance.
*
* @param bname binding name
* @param pack target package for binding
* @param loader class loader to be used for loading factory
* @return binding factory instance
* @throws JiBXException on any error in finding or accessing factory
*/
public static IBindingFactory getFactory(String bname, String pack,
ClassLoader loader) throws JiBXException {
String cname = (pack == null ? "" : pack + '.') +
GENERATE_PREFIX + convertName(bname) + BINDINGFACTORY_SUFFIX;
Throwable ex = null;
Object result = null;
IBindingFactory ifact = null;
try {
Class factory = loader.loadClass(cname);
Method method = factory.getMethod(FACTORY_INSTMETHOD, EMPTY_ARGS);
result = method.invoke(null, (Object[])null);
} catch (SecurityException e) {
ex = e;
} catch (ClassNotFoundException e) {
ex = e;
} catch (NoSuchMethodException e) {
ex = e;
} catch (IllegalAccessException e) {
ex = e;
} catch (InvocationTargetException e) {
ex = e;
} finally {
if (ex == null) {
if (result instanceof IBindingFactory) {
ifact = (IBindingFactory)result;
int diff = ifact.getCompilerVersion() ^
IBindingFactory.CURRENT_VERSION_NUMBER;
if ((diff & IBindingFactory.COMPATIBLE_VERSION_MASK) != 0) {
throw new JiBXException
("Binding '" + bname +
"' must be recompiled with current binding " +
"compiler (compiled with " +
ifact.getCompilerDistribution() + ", runtime is " +
IBindingFactory.CURRENT_VERSION_NAME + ")");
}
} else {
throw new JiBXException
("Classloader conflict for binding '" + bname +
"' - factory does not implement required interface");
}
} else {
throw new JiBXException
("Unable to access binding '" + bname +
"'\nMake sure classes generated by the " +
"binding compiler are available at runtime", ex);
}
}
return ifact;
}
/**
* Get instance of binding factory. Finds the binding factory for the named
* binding compiled to the specified package, then loads that factory and
* returns an instance.
*
* @param bname binding name
* @param pack target package for binding
* @return binding factory instance
* @throws JiBXException on any error in finding or accessing factory
*/
public static IBindingFactory getFactory(String bname, String pack)
throws JiBXException {
return getFactory(bname, pack,
BindingDirectory.class.getClassLoader());
}
/**
* Generate binding name. This takes a base name (such as a file name with
* extension stripped off) and converts it to legal form by substituting '_'
* characters for illegal characters in the base name.
*
* @param name base binding name
* @return converted binding name
*/
public static String convertName(String name) {
// convert name to use only legal characters
StringBuffer buff = new StringBuffer(name);
for (int i = 0; i < buff.length(); i++) {
if (!Character.isJavaIdentifierPart(buff.charAt(i))) {
buff.setCharAt(i, '_');
}
}
return buff.toString();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/IListItemDeserializer.java 0000644 0001750 0001750 00000003703 10434260716 026411 0 ustar twerner twerner /*
Copyright (c) 2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
/**
* Schema list component deserializer interface. This is a convenience for
* defining list variations of basic types.
*
* @author Dennis M. Sosnoski
*/
public interface IListItemDeserializer
{
/**
* Deserializer method for list items.
*
* @param text value text
* @return created item class instance
* @exception JiBXException on error deserializing text
*/
public Object deserialize(String text) throws JiBXException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/IMarshaller.java 0000644 0001750 0001750 00000006720 11043445700 024403 0 ustar twerner twerner /*
Copyright (c) 2002-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
/**
* Marshaller interface definition. This interface must be implemented
* by the handler for marshalling an object.
*
* Instances of classes implementing this interface must be serially
* reusable, meaning they can store state information while in the process
* of marshalling an object but must reset all state when called to
* marshal another object after the first one is done (even if the first
* object throws an exception during marshalling).
*
* The JiBX framework will only create one instance of a marshaller class (per
* marshalling context) for each mapped class using that marshaller. Generally
* the marshaller instance will not be called recursively, but this may happen
* in cases where the binding definition includes recursive mappings and the
* marshaller uses other marshallers (as opposed to handling all children
* directly).
*
* @author Dennis M. Sosnoski
*/
public interface IMarshaller
{
/**
* Check if marshaller represents an extension mapping. This is used by the
* framework in generated code to verify compatibility of objects being
* marshalled using an abstract mapping.
*
* @param mapname marshaller mapping name (generally the class name to be
* handled, or abstract mapping type name)
* @return true if this mapping is an extension of the abstract
* mapping, false if not
*/
boolean isExtension(String mapname);
/**
* Marshal instance of handled class. This method call is responsible
* for all handling of the marshalling of an object to XML text. It is
* called at the point where the start tag for the associated element
* should be generated.
*
* @param obj object to be marshalled (may be null if property
* is not optional)
* @param ctx XML text output context
* @throws JiBXException on error in marshalling process
*/
void marshal(Object obj, IMarshallingContext ctx) throws JiBXException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/JiBXConstrainedParseException.java 0000644 0001750 0001750 00000006040 11003053146 030026 0 ustar twerner twerner /*
Copyright (c) 2008, Joshua Davies.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import java.util.Arrays;
/**
* Thrown when a "constrained" parsing exception is encountered (e.g. an
* enumerated value).
*
* @author Joshua Davies
*/
public class JiBXConstrainedParseException extends JiBXParseException {
private String[] m_allowableValues;
public JiBXConstrainedParseException(String msg, String value,
String[] allowableValues) {
super(msg, value);
m_allowableValues = allowableValues;
}
public JiBXConstrainedParseException(String msg, String value,
String[] allowableValues, String namespace, String tagName,
Throwable root) {
super(msg, value, namespace, tagName, root);
m_allowableValues = allowableValues;
}
/**
* @return the default message with "constraint" text appended.
*/
public String getMessage() {
StringBuffer constraint = new StringBuffer();
constraint.append(". Acceptable values are ");
for (int i = 0; i < m_allowableValues.length; i++) {
constraint.append("'" + m_allowableValues[i] + "'");
if (i < (m_allowableValues.length - 1)) {
constraint.append(", ");
}
}
return super.getMessage() + constraint.toString() + ".";
}
/**
* Solely used by unit tests.
*
* @param obj what to compare against
* @return true or false
*/
public boolean equals(Object obj) {
if (this == obj)
return true;
if (!super.equals(obj))
return false;
if (getClass() != obj.getClass())
return false;
final JiBXConstrainedParseException other = (JiBXConstrainedParseException) obj;
if (!Arrays.equals(m_allowableValues, other.m_allowableValues))
return false;
return true;
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/ 0000755 0001750 0001750 00000000000 11526304016 022271 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/StringIntHashMap.java 0000644 0001750 0001750 00000035727 10263166014 026336 0 ustar twerner twerner /*
* Copyright (c) 2000-2005, Dennis M. Sosnoski. 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. Neither the name of JiBX nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 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 OWNER 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.jibx.runtime.impl;
/**
* Hash map using String values as keys mapped to primitive
* int values. This implementation is unsynchronized in order to
* provide the best possible performance for typical usage scenarios, so
* explicit synchronization must be implemented by a wrapper class or directly
* by the application in cases where instances are modified in a multithreaded
* environment. The map implementation is not very efficient when resizing, but
* works well when the size of the map is known in advance.
*
* @author Dennis M. Sosnoski
* @version 1.1
*/
public class StringIntHashMap
{
/** Default value returned when key not found in table. */
public static final int DEFAULT_NOT_FOUND = Integer.MIN_VALUE;
/** Default fill fraction allowed before growing table. */
protected static final double DEFAULT_FILL = 0.3d;
/** Minimum size used for hash table. */
protected static final int MINIMUM_SIZE = 31;
/** Fill fraction allowed for this hash table. */
protected final double m_fillFraction;
/** Number of entries present in table. */
protected int m_entryCount;
/** Entries allowed before growing table. */
protected int m_entryLimit;
/** Size of array used for keys. */
protected int m_arraySize;
/** Offset added (modulo table size) to slot number on collision. */
protected int m_hitOffset;
/** Array of key table slots. */
protected String[] m_keyTable;
/** Array of value table slots. */
protected int[] m_valueTable;
/** Value returned when key not found in table. */
protected int m_notFoundValue;
/**
* Constructor with full specification.
*
* @param count number of values to assume in initial sizing of table
* @param fill fraction full allowed for table before growing
* @param miss value returned when key not found in table
*/
public StringIntHashMap(int count, double fill, int miss) {
// check the passed in fill fraction
if (fill <= 0.0d || fill >= 1.0d) {
throw new IllegalArgumentException("fill value out of range");
}
m_fillFraction = fill;
// compute initial table size (ensuring odd)
m_arraySize = Math.max((int)(count / m_fillFraction), MINIMUM_SIZE);
m_arraySize += (m_arraySize + 1) % 2;
// initialize the table information
m_entryLimit = (int)(m_arraySize * m_fillFraction);
m_hitOffset = m_arraySize / 2;
m_keyTable = new String[m_arraySize];
m_valueTable = new int[m_arraySize];
m_notFoundValue = miss;
}
/**
* Constructor with size and fill fraction specified. Uses default hash
* technique and value returned when key not found in table.
*
* @param count number of values to assume in initial sizing of table
* @param fill fraction full allowed for table before growing
*/
public StringIntHashMap(int count, double fill) {
this(count, fill, DEFAULT_NOT_FOUND);
}
/**
* Constructor with only size supplied. Uses default hash technique and
* values for fill fraction and value returned when key not found in table.
*
* @param count number of values to assume in initial sizing of table
*/
public StringIntHashMap(int count) {
this(count, DEFAULT_FILL);
}
/**
* Default constructor.
*/
public StringIntHashMap() {
this(0, DEFAULT_FILL);
}
/**
* Copy (clone) constructor.
*
* @param base instance being copied
*/
public StringIntHashMap(StringIntHashMap base) {
// copy the basic occupancy information
m_fillFraction = base.m_fillFraction;
m_entryCount = base.m_entryCount;
m_entryLimit = base.m_entryLimit;
m_arraySize = base.m_arraySize;
m_hitOffset = base.m_hitOffset;
m_notFoundValue = base.m_notFoundValue;
// copy table of items
m_keyTable = new String[m_arraySize];
System.arraycopy(base.m_keyTable, 0, m_keyTable, 0, m_arraySize);
m_valueTable = new int[m_arraySize];
System.arraycopy(base.m_valueTable, 0, m_valueTable, 0, m_arraySize);
}
/**
* Step the slot number for an entry. Adds the collision offset (modulo
* the table size) to the slot number.
*
* @param slot slot number to be stepped
* @return stepped slot number
*/
private final int stepSlot(int slot) {
return (slot + m_hitOffset) % m_arraySize;
}
/**
* Find free slot number for entry. Starts at the slot based directly
* on the hashed key value. If this slot is already occupied, it adds
* the collision offset (modulo the table size) to the slot number and
* checks that slot, repeating until an unused slot is found.
*
* @param slot initial slot computed from key
* @return slot at which entry was added
*/
private final int freeSlot(int slot) {
while (m_keyTable[slot] != null) {
slot = stepSlot(slot);
}
return slot;
}
/**
* Standard base slot computation for a key.
*
* @param key key value to be computed
* @return base slot for key
*/
private final int standardSlot(Object key) {
return (key.hashCode() & Integer.MAX_VALUE) % m_arraySize;
}
/**
* Standard find key in table. This method may be used directly for key
* lookup using either the hashCode() method defined for the
* key objects or the System.identityHashCode() method, and
* either the equals() method defined for the key objects or
* the == operator, as selected by the hash technique
* constructor parameter. To implement a hash class based on some other
* methods of hashing and/or equality testing, define a separate method in
* the subclass with a different name and use that method instead. This
* avoids the overhead caused by overrides of a very heavily used method.
*
* @param key to be found in table
* @return index of matching key, or -index-1 of slot to be
* used for inserting key in table if not already present (always negative)
*/
private int standardFind(Object key) {
// find the starting point for searching table
int slot = standardSlot(key);
// scan through table to find target key
while (m_keyTable[slot] != null) {
// check if we have a match on target key
if (m_keyTable[slot].equals(key)) {
return slot;
} else {
slot = stepSlot(slot);
}
}
return -slot-1;
}
/**
* Reinsert an entry into the hash map. This is used when the table is being
* directly modified, and does not adjust the count present or check the
* table capacity.
*
* @param slot position of entry to be reinserted into hash map
* @return true if the slot number used by the entry has has
* changed, false if not
*/
private boolean reinsert(int slot) {
String key = m_keyTable[slot];
m_keyTable[slot] = null;
return assignSlot(key, m_valueTable[slot]) != slot;
}
/**
* Internal remove pair from the table. Removes the pair from the table
* by setting the key entry to null and adjusting the count
* present, then chains through the table to reinsert any other pairs
* which may have collided with the removed pair. If the associated value
* is an object reference, it should be set to null before
* this method is called.
*
* @param slot index number of pair to be removed
*/
protected void internalRemove(int slot) {
// delete pair from table
m_keyTable[slot] = null;
m_entryCount--;
while (m_keyTable[(slot = stepSlot(slot))] != null) {
// reinsert current entry in table to fill holes
reinsert(slot);
}
}
/**
* Restructure the table. This is used when the table is increasing or
* decreasing in size, and works directly with the old table representation
* arrays. It inserts pairs from the old arrays directly into the table
* without adjusting the count present or checking the table size.
*
* @param keys array of keys
* @param values array of values
*/
private void restructure(String[] keys, int[] values) {
for (int i = 0; i < keys.length; i++) {
if (keys[i] != null) {
assignSlot(keys[i], values[i]);
}
}
}
/**
* Assign slot for entry. Starts at the slot found by the hashed key value.
* If this slot is already occupied, it steps the slot number and checks the
* resulting slot, repeating until an unused slot is found. This method does
* not check for duplicate keys, so it should only be used for internal
* reordering of the tables.
*
* @param key to be added to table
* @param value associated value for key
* @return slot at which entry was added
*/
private int assignSlot(String key, int value) {
int offset = freeSlot(standardSlot(key));
m_keyTable[offset] = key;
m_valueTable[offset] = value;
return offset;
}
/**
* Add an entry to the table. If the key is already present in the table,
* this replaces the existing value associated with the key.
*
* @param key key to be added to table (non- null)
* @param value associated value for key
* @return value previously associated with key, or reserved not found value
* if key not previously present in table
*/
public int add(String key, int value) {
// first validate the parameters
if (key == null) {
throw new IllegalArgumentException("null key not supported");
} else if (value == m_notFoundValue) {
throw new IllegalArgumentException(
"value matching not found return not supported");
} else {
// check space available
int min = m_entryCount + 1;
if (min > m_entryLimit) {
// find the array size required
int size = m_arraySize;
int limit = m_entryLimit;
while (limit < min) {
size = size * 2 + 1;
limit = (int) (size * m_fillFraction);
}
// set parameters for new array size
m_arraySize = size;
m_entryLimit = limit;
m_hitOffset = size / 2;
// restructure for larger arrays
String[] keys = m_keyTable;
m_keyTable = new String[m_arraySize];
int[] values = m_valueTable;
m_valueTable = new int[m_arraySize];
restructure(keys, values);
}
// find slot of table
int offset = standardFind(key);
if (offset >= 0) {
// replace existing value for key
int prior = m_valueTable[offset];
m_valueTable[offset] = value;
return prior;
} else {
// add new pair to table
m_entryCount++;
offset = -offset - 1;
m_keyTable[offset] = key;
m_valueTable[offset] = value;
return m_notFoundValue;
}
}
}
/**
* Check if an entry is present in the table. This method is supplied to
* support the use of values matching the reserved not found value.
*
* @param key key for entry to be found
* @return true if key found in table, false
* if not
*/
public final boolean containsKey(String key) {
return standardFind(key) >= 0;
}
/**
* Find an entry in the table.
*
* @param key key for entry to be returned
* @return value for key, or reserved not found value if key not found
*/
public final int get(String key) {
int slot = standardFind(key);
if (slot >= 0) {
return m_valueTable[slot];
} else {
return m_notFoundValue;
}
}
/**
* Remove an entry from the table. If multiple entries are present with the
* same key value, only the first one found will be removed.
*
* @param key key to be removed from table
* @return value associated with removed key, or reserved not found value if
* key not found in table
*/
public int remove(String key) {
int slot = standardFind(key);
if (slot >= 0) {
int value = m_valueTable[slot];
internalRemove(slot);
return value;
} else {
return m_notFoundValue;
}
}
/**
* Construct a copy of the table.
*
* @return shallow copy of table
*/
public Object clone() {
return new StringIntHashMap(this);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/XMLPullReaderFactory.java 0000644 0001750 0001750 00000042164 11070741336 027117 0 ustar twerner twerner /*
Copyright (c) 2005-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import org.jibx.runtime.IXMLReader;
import org.jibx.runtime.JiBXException;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;
/**
* Factory for creating XMLPull parser instances.
*
* @author Dennis M. Sosnoski
*/
public class XMLPullReaderFactory implements IXMLReaderFactory
{
/** Default parser factory name when nothing else found. */
private static final String DEFAULT_PARSER_NAME =
"org.xmlpull.mxp1.MXParserFactory";
/** Singleton instance of class. */
private static final XMLPullReaderFactory s_instance;
static {
// first try getting factory defined by property value
XmlPullParserFactory factory = null;
ClassLoader loader = Thread.currentThread().getContextClassLoader();
if (loader == null) {
loader = XMLPullReaderFactory.class.getClassLoader();
}
try {
String name =
System.getProperty(XmlPullParserFactory.PROPERTY_NAME);
if (name != null && (name = name.trim()).length() > 0) {
factory = XmlPullParserFactory.newInstance(name,
loader.getClass());
}
} catch (Exception ex) { /* deliberately empty */ }
// if no luck that way, try getting it directly
if (factory == null) {
try {
factory = XmlPullParserFactory.newInstance();
} catch (Exception ex) { /* deliberately empty */ }
if (factory == null) {
throw new RuntimeException("Unable to create XMLPull parser");
}
}
s_instance = new XMLPullReaderFactory(factory);
}
/** Factory used for constructing parser instances. */
private final XmlPullParserFactory m_factory;
/**
* Internal constructor.
*
* @param factory
*/
private XMLPullReaderFactory(XmlPullParserFactory factory) {
m_factory = factory;
}
/**
* Get instance of factory.
*
* @return factory instance
*/
public static XMLPullReaderFactory getInstance() {
return s_instance;
}
/**
* Create new parser instance.
*
* @param nsf enable namespace processing on parser flag
* @return parser instance
* @throws XmlPullParserException on error creating parser
*/
private XmlPullParser createParser(boolean nsf)
throws XmlPullParserException {
XmlPullParser parser = m_factory.newPullParser();
if (nsf) {
parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true);
}
return parser;
}
/* (non-Javadoc)
* @see org.jibx.runtime.impl.IXMLReaderFactory#createReader(java.io.InputStream, java.lang.String, java.lang.String, boolean)
*/
public IXMLReader createReader(InputStream is, String name, String enc,
boolean nsf) throws JiBXException {
try {
return recycleReader(new XMLPullReader(createParser(nsf)), is,
name, enc);
} catch (XmlPullParserException e) {
throw new JiBXException("Error creating parser", e);
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.impl.IXMLReaderFactory#createReader(java.io.Reader, java.lang.String, boolean)
*/
public IXMLReader createReader(Reader rdr, String name, boolean nsf)
throws JiBXException {
try {
return recycleReader(new XMLPullReader(createParser(nsf)),
rdr, name);
} catch (XmlPullParserException e) {
throw new JiBXException("Error creating parser", e);
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.impl.IXMLReaderFactory#recycleReader(org.jibx.runtime.IXMLReader, java.io.InputStream, java.lang.String, java.lang.String)
*/
public IXMLReader recycleReader(IXMLReader old, InputStream is, String name,
String enc) throws JiBXException {
((XMLPullReader)old).setDocument(is, name, enc);
return old;
}
/* (non-Javadoc)
* @see org.jibx.runtime.impl.IXMLReaderFactory#recycleReader(org.jibx.runtime.IXMLReader, java.io.Reader, java.lang.String)
*/
public IXMLReader recycleReader(IXMLReader old, Reader rdr, String name)
throws JiBXException {
((XMLPullReader)old).setDocument(rdr, name);
return old;
}
/**
* Wrapper for an XMLPull parser implementation. Since the internal parser
* API was originally based on XMLPull, this basically just delegates all
* the calls with minimal processing.
*/
private static class XMLPullReader implements IXMLReader
{
/** Actual parser. */
private final XmlPullParser m_parser;
/** Document name. */
private String m_docName;
/** Byte buffer used when stream set directly (lazy create,
null if not used). */
private InByteBuffer m_byteBuffer;
/** Wrapper for supplied input stream (lazy create, null
if not used). */
private InputStreamWrapper m_streamWrapper;
/** Input document character encoding (null if unknown) */
private String m_encoding;
/**
* Constructor used by factory.
*
* @param parser
*/
private XMLPullReader(XmlPullParser parser) {
m_parser = parser;
}
/**
* Set document to be parsed from input stream.
*
* @param is document input stream
* @param name document name (null if unknown)
* @param enc document character encoding (null if unknown)
* @throws JiBXException on parser configuration error
*/
private void setDocument(InputStream is, String name, String enc)
throws JiBXException {
try {
if (enc == null) {
if (m_streamWrapper == null) {
m_streamWrapper = new InputStreamWrapper();
m_byteBuffer = new InByteBuffer();
m_streamWrapper.setBuffer(m_byteBuffer);
} else {
m_streamWrapper.reset();
}
m_byteBuffer.setInput(is);
setDocument(m_streamWrapper.getReader(), name);
m_encoding = m_streamWrapper.getEncoding();
} else {
m_docName = name;
m_encoding = enc;
m_parser.setInput(is, enc);
}
} catch (XmlPullParserException e) {
throw new JiBXException("Error initializing parser", e);
} catch (IOException e) {
throw new JiBXException("Error reading from stream", e);
}
}
/**
* Set document to be parsed from reader.
*
* @param rdr document reader
* @param name document name (null if unknown)
* @throws JiBXException on parser configuration error
*/
private void setDocument(Reader rdr, String name) throws JiBXException {
try {
m_docName = name;
m_encoding = null;
m_parser.setInput(rdr);
} catch (XmlPullParserException e) {
throw new JiBXException("Error initializing parser", e);
}
}
/**
* Format error message from exception.
*
* @param e root cause exception
*/
private String describeException(Exception e) {
return "Error parsing document " + buildPositionString() + ": " +
e.getMessage();
}
public void init() {}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#buildPositionString()
*/
public String buildPositionString() {
String base = "(line " + m_parser.getLineNumber() + ", col " +
m_parser.getColumnNumber();
if (m_docName != null) {
base += ", in " + m_docName;
}
return base + ')';
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#nextToken()
*/
public int nextToken() throws JiBXException {
try {
return m_parser.nextToken();
} catch (IOException e) {
throw new JiBXException("Error accessing document", e);
} catch (XmlPullParserException e) {
throw new JiBXException
("Error parsing document " + buildPositionString(), e);
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#next()
*/
public int next() throws JiBXException {
try {
return m_parser.next();
} catch (IOException e) {
throw new JiBXException("Error accessing document", e);
} catch (XmlPullParserException e) {
throw new JiBXException
("Error parsing document " + buildPositionString(), e);
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getEventType()
*/
public int getEventType() throws JiBXException {
try {
return m_parser.getEventType();
} catch (XmlPullParserException e) {
throw new JiBXException
("Error parsing document " + buildPositionString(), e);
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getName()
*/
public String getName() {
String name = m_parser.getName();
if (name == null) {
throw new IllegalStateException
("Internal state error: not at start or end tag");
} else {
return name;
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getNamespace()
*/
public String getNamespace() {
String uri = m_parser.getNamespace();
if (uri == null) {
throw new IllegalStateException
("Internal state error: not at start or end tag");
} else {
return uri;
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getPrefix()
*/
public String getPrefix() {
return m_parser.getPrefix();
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getAttributeCount()
*/
public int getAttributeCount() {
int count = m_parser.getAttributeCount();
if (count < 0) {
throw new IllegalStateException
("Internal state error: not at start tag");
} else {
return count;
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getAttributeName(int)
*/
public String getAttributeName(int index) {
try {
return m_parser.getAttributeName(index);
} catch (ArrayIndexOutOfBoundsException e) {
throw new IllegalStateException(describeException(e));
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getAttributeNamespace(int)
*/
public String getAttributeNamespace(int index) {
try {
return m_parser.getAttributeNamespace(index);
} catch (ArrayIndexOutOfBoundsException e) {
throw new IllegalStateException(describeException(e));
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getAttributePrefix(int)
*/
public String getAttributePrefix(int index) {
try {
return m_parser.getAttributePrefix(index);
} catch (ArrayIndexOutOfBoundsException e) {
throw new IllegalStateException(describeException(e));
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getAttributeValue(int)
*/
public String getAttributeValue(int index) {
try {
return m_parser.getAttributeValue(index);
} catch (ArrayIndexOutOfBoundsException e) {
throw new IllegalStateException(describeException(e));
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getAttributeValue(java.lang.String, java.lang.String)
*/
public String getAttributeValue(String ns, String name) {
try {
return m_parser.getAttributeValue(ns, name);
} catch (ArrayIndexOutOfBoundsException e) {
throw new IllegalStateException(describeException(e));
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getText()
*/
public String getText() {
return m_parser.getText();
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getNestingDepth()
*/
public int getNestingDepth() {
return m_parser.getDepth();
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getNamespaceCount(int)
*/
public int getNamespaceCount(int depth) {
try {
return m_parser.getNamespaceCount(depth);
} catch (XmlPullParserException e) {
throw new IllegalArgumentException(describeException(e));
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getNamespaceUri(int)
*/
public String getNamespaceUri(int index) {
try {
return m_parser.getNamespaceUri(index);
} catch (XmlPullParserException e) {
throw new IllegalArgumentException(describeException(e));
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getNamespacePrefix(int)
*/
public String getNamespacePrefix(int index) {
try {
return m_parser.getNamespacePrefix(index);
} catch (XmlPullParserException e) {
throw new IllegalArgumentException(describeException(e));
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getDocumentName()
*/
public String getDocumentName() {
return m_docName;
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getLineNumber()
*/
public int getLineNumber() {
return m_parser.getLineNumber();
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getColumnNumber()
*/
public int getColumnNumber() {
return m_parser.getColumnNumber();
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getNamespace(java.lang.String)
*/
public String getNamespace(String prefix) {
return m_parser.getNamespace(prefix);
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getInputEncoding()
*/
public String getInputEncoding() {
return m_encoding;
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#isNamespaceAware()
*/
public boolean isNamespaceAware() {
return m_parser.getFeature
(XmlPullParser.FEATURE_PROCESS_NAMESPACES);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/IInByteBuffer.java 0000644 0001750 0001750 00000005377 11067527610 025614 0 ustar twerner twerner /*
Copyright (c) 2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
/**
* Input buffer interface. This extends the basic byte array buffer interface
* with methods specifically for input. Client code needs to obey the access
* rules stated in the method documentation, including the documentation for the
* base interface methods.
*
* @author Dennis M. Sosnoski
*/
public interface IInByteBuffer extends IByteBuffer
{
/**
* Require some number of bytes of data. When this call is made the buffer
* can discard all data up to the current offset, and may move retained data
* within the buffer array and read more data from the data source to make
* the requested number of bytes available. This call may cause the byte
* array buffer to be replaced, so {@link #getBuffer()},
* {@link #getLimit()}, and {@link #getOffset()} must all be called again
* before any further use of the buffer.
*
* @param size desired number of bytes
* @return true if request satisfied, false if end
* with less than request available
* @throws IOException
*/
boolean require(int size) throws IOException;
/**
* Get offset past the end of data in buffer.
*
* @return offset past end of data
*/
int getLimit();
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/BindingFactoryBase.java 0000644 0001750 0001750 00000053017 11160702736 026644 0 ustar twerner twerner /*
Copyright (c) 2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
/**
* Base class for generated binding factories. This provides common
* implementation code, so that the code does not need to be duplicated in every
* generated binding factory.
*
* @author Dennis M. Sosnoski
*/
public abstract class BindingFactoryBase implements IBindingFactory
{
private static final int[] EMPTY_INT_ARRAY = new int[0];
private final String m_bindingName;
private final int m_majorVersion;
private final int m_minorVersion;
private final String[] m_bindingClasses;
private final String[] m_mapNames;
private final StringIntHashMap m_classIndexMap;
private final String[] m_unmarshallers;
private final String[] m_marshallers;
private final String[] m_uris;
private final String[] m_prefixes;
private final String[] m_globalNames;
private final String[] m_globalUris;
private final String[] m_idClassNames;
private final String[][] m_abstractMappingDetails;
private final int[][] m_abstractMappingNamespaces;
private final String[] m_baseNames;
private final String m_baseHashes;
private final String[] m_bindingFactories;
private final Class[] m_marshallerClasses;
private final Class[] m_unmarshallerClasses;
private final Map m_bindingNamespaceTables;
private final int m_hash;
private boolean m_verified;
private String[] m_bindingClassesClosure;
private Map m_unmarshalMap;
/**
* Constructor used in generated binding factories.
*
* @param name binding name
* @param majorver binding major version number
* @param minorver binding minor version number
* @param boundnames blob of class names with code for this binding
* @param mappednames blob of class or type names for mappings
* @param umarnames unmarshaller class names blob (null if
* output-only binding)
* @param marnames marshaller class names blob (null if
* input-only binding)
* @param uris namespace URIs used by binding
* @param prefixes namespace prefixes used by binding (null
* if input-only binding)
* @param gmapnames globally-mapped element names blob
* @param gmapuris globally-mapped element namespaces blob
* @param idclasses names of classes with IDs
* @param abmapdetails abstract mapping details blob
* @param abmapnss abstract mapping namespace indexes blob
* @param prenames precompiled base binding names blob
* @param prefacts base binding factory classes blob
* @param prehashes base binding hashes blob
* @param prensmaps namespace index mapping tables blobs for precompiled
* bindings
*/
protected BindingFactoryBase(String name, int majorver, int minorver,
String boundnames, String mappednames, String umarnames,
String marnames, String[] uris, String[] prefixes, String gmapnames,
String gmapuris, String[] idclasses, String abmapdetails,
String abmapnss, String prenames, String prefacts, String prehashes,
String[] prensmaps) {
m_bindingName = name;
m_majorVersion = majorver;
m_minorVersion = minorver;
m_bindingClasses = RuntimeSupport.splitClassNames(boundnames);
m_mapNames = RuntimeSupport.splitClassNames(mappednames);
m_classIndexMap = new StringIntHashMap(m_mapNames.length, 0.1);
for (int i = 0; i < m_mapNames.length; i++) {
m_classIndexMap.add(m_mapNames[i], i);
}
if (marnames == null) {
m_marshallers = null;
m_marshallerClasses = new Class[0];
} else {
m_marshallers = RuntimeSupport.splitClassNames(marnames);
m_marshallerClasses = new Class[m_marshallers.length];
}
if (umarnames == null) {
m_unmarshallers = null;
m_unmarshallerClasses = new Class[0];
} else {
m_unmarshallers = RuntimeSupport.splitClassNames(umarnames);
m_unmarshallerClasses = new Class[m_unmarshallers.length];
}
m_uris = uris;
m_prefixes = prefixes;
m_globalNames = RuntimeSupport.splitNames(gmapnames);
m_globalUris = RuntimeSupport.expandNamespaces(gmapuris, uris);
m_idClassNames = idclasses;
String[] names = RuntimeSupport.splitClassNames(abmapdetails);
int abmapcount = names.length / ABMAP_COUNT;
String[][] details = new String[ABMAP_COUNT][];
for (int i = 0; i < ABMAP_COUNT; i++) {
details[i] = new String[abmapcount];
}
for (int i = 0; i < names.length; i++) {
details[i%ABMAP_COUNT][i/ABMAP_COUNT] = names[i];
}
m_abstractMappingDetails = details;
int[][] nss = new int[abmapcount][];
int base = 0;
for (int i = 0; i < abmapcount; i++) {
int length = abmapnss.charAt(base++);
if (length == 1) {
nss[i] = EMPTY_INT_ARRAY;
} else {
int[] indexes = new int[--length];
for (int j = 0; j < length; j++) {
indexes[j] = abmapnss.charAt(base+j) - 1;
}
base += length;
nss[i] = indexes;
}
}
m_abstractMappingNamespaces = nss;
m_baseNames = RuntimeSupport.splitNames(prenames);
m_baseHashes = prehashes;
m_bindingFactories = RuntimeSupport.splitClassNames(prefacts);
Map tablemap = new HashMap();
for (int i = 0; i < prensmaps.length; i++) {
String blob = prensmaps[i];
if (blob != null) {
int[] indexes = RuntimeSupport.splitInts(blob);
tablemap.put(m_bindingFactories[i], indexes);
}
}
m_bindingNamespaceTables = tablemap;
// compute the hash code for this binding
int hash = name.hashCode() + majorver + minorver +
boundnames.hashCode() + mappednames.hashCode();
if (umarnames != null) {
hash += umarnames.hashCode();
}
if (marnames != null) {
hash += marnames.hashCode();
}
for (int i = 0; i < uris.length; i++) {
hash += uris[i].hashCode();
}
if (prefixes != null) {
for (int i = 0; i < prefixes.length; i++) {
String prefix = prefixes[i];
if (prefix != null) {
hash += prefix.hashCode();
}
}
}
hash += gmapnames.hashCode() + gmapuris.hashCode();
if (idclasses != null) {
for (int i = 0; i < idclasses.length; i++) {
hash += idclasses[i].hashCode();
}
}
hash += abmapdetails.hashCode() + abmapnss.hashCode() +
prenames.hashCode() + prefacts.hashCode();
m_hash = hash;
}
/**
* Load a class. This first tries to load the specified class using the
* classloader that loaded the binding factory instance, then tries the
* thread context classloader, then finally tries the classloader used to
* load this class.
*
* @param name fully qualified class name
* @return loaded class, or null if class not found
*/
public Class loadClass(String name) {
// first try loading class from instance class loader
Class clas = null;
ClassLoader factldr = null;
factldr = getClass().getClassLoader();
try {
clas = factldr.loadClass(name);
} catch (ClassNotFoundException e) { /* fall through */ }
if (clas == null) {
// next try the context class loader, if set
ClassLoader ctxldr = Thread.currentThread().getContextClassLoader();
if (ctxldr != null) {
try {
clas = ctxldr.loadClass(name);
} catch (ClassNotFoundException e) { /* fall through */ }
}
if (clas == null) {
// not found, try the loader that loaded this class
ClassLoader thisldr = BindingFactoryBase.class.getClassLoader();
if (thisldr != factldr && thisldr != ctxldr) {
try {
clas = thisldr.loadClass(name);
} catch (ClassNotFoundException e)
{ /* fall through */ }
}
}
}
return clas;
}
/**
* Create a new marshalling context.
*
* @return context
* @throws JiBXException
*/
public IMarshallingContext createMarshallingContext() throws JiBXException {
return new MarshallingContext(m_mapNames, m_marshallers, m_uris, this);
}
/**
* Create a new unmarshalling context.
*
* @return context
* @throws JiBXException
*/
public IUnmarshallingContext createUnmarshallingContext()
throws JiBXException {
return new UnmarshallingContext(m_unmarshallers.length, m_unmarshallers,
m_globalUris, m_globalNames, m_idClassNames, this);
}
/**
* Get the binding name.
*
* @return name
*/
public String getBindingName() {
return m_bindingName;
}
/**
* Get hash for binding. The computed hash value is based on all the values
* returned by all the methods of this interface, with the exception of the
* {@link #getMarshallerClass(int)} and {@link #getUnmarshallerClass(int)}
* methods returning Class objects.
*
* @return hash
*/
public int getHash() {
return m_hash;
}
/**
* Get major version number.
*
* @return major version
*/
public int getMajorVersion() {
return m_majorVersion;
}
/**
* Get minor version number.
*
* @return minor version
*/
public int getMinorVersion() {
return m_minorVersion;
}
/**
* Get the classes used by the binding. Every class which includes code
* generated by the binding compiler for this binding or any precompiled
* base binding is included in the returned array. If {@link
* #verifyBaseBindings()} has not already been invoked it will be invoked by
* this call.
*
* @return fully-qualified class names
* @throws JiBXException on base binding verification error
*/
public String[] getBindingClasses() throws JiBXException {
verifyBaseBindings();
return m_bindingClassesClosure;
}
/**
* Get global-mapped element names.
*
* @return names
*/
public String[] getElementNames() {
return m_globalNames;
}
/**
* Get marshaller class names.
*
* @return array of class names
*/
public String[] getMarshallerClasses() {
return m_marshallers;
}
/**
* Get unmarshaller class names.
*
* @return array of class names
*/
public String[] getUnmarshallerClasses() {
return m_unmarshallers;
}
/**
* Get global-mapped element namespace URIs.
*
* @return uris
*/
public String[] getElementNamespaces() {
return m_globalUris;
}
/**
* Get mapped class names (or type names, in the case of abstract mappings).
* Returns array of fully-qualified class and/or type names, ordered by
* index number of the class.
*
* @return array of class names
*/
public String[] getMappedClasses() {
return m_mapNames;
}
/**
* Get map from fully-qualified class name to the index number of the class
* used for accessing the arrays of class names. The value returned is the
* index for the class in the arrays returned by {@link
* #getMappedClasses()}, {@link #getMarshallerClasses()}, and {@link
* #getUnmarshallerClasses()}, and can also be used as input for {@link
* #getMarshallerClass(int)} and {@link #getUnmarshallerClass(int)}.
*
* @return map from fully-qualified class name to index number
*/
public StringIntHashMap getClassIndexMap() {
return m_classIndexMap;
}
/**
* Get the linkage information for global abstract mappings included in the
* binding. See {@link IBindingFactory#getAbstractMappings()} for details.
*
* @return method information array
*/
public String[][] getAbstractMappings() {
return m_abstractMappingDetails;
}
/**
* Get the indexes of the namespaces used by an abstract mapping.
*
* @param index abstract mapping index, corresponding to the abstract
* mapping information returned by {@link #getAbstractMappings()}.
* @return namespace indexes, empty array if none
*/
public int[] getAbstractMappingNamespaces(int index) {
return m_abstractMappingNamespaces[index];
}
/**
* Get the namespace URIs used by the binding.
*
* @return uris
*/
public String[] getNamespaces() {
return m_uris;
}
/**
* Get the names of the separately-compiled base bindings used by this
* binding.
*
* @return binding names
*/
public String[] getBaseBindings() {
return m_baseNames;
}
/**
* Verify that separately-compiled base bindings used by this binding can be
* loaded and are compatible with the base bindings used when this binding
* was compiled.
*
* @throws JiBXException on verification failure
*/
public void verifyBaseBindings() throws JiBXException {
if (!m_verified) {
if (m_bindingFactories.length == 0) {
m_bindingClassesClosure = m_bindingClasses;
} else {
// access binding factories to verify hashes and get classes
GrowableStringArray classes = new GrowableStringArray();
for (int i = 0; i < m_bindingFactories.length; i++) {
String fname = m_bindingFactories[i];
Class fclas = loadClass(fname);
if (fclas == null) {
throw new JiBXException("Unable to load precompiled base binding '" + m_baseNames[i] + "' used by binding '" + getBindingName() + '\'');
} else {
Exception ex = null;
try {
Method method = fclas.getMethod
(BindingDirectory.FACTORY_INSTMETHOD,
BindingDirectory.EMPTY_ARGS);
Object result = method.invoke(null, (Object[])null);
if (result instanceof IBindingFactory) {
IBindingFactory fact = (IBindingFactory)result;
int match = (m_baseHashes.charAt(i*2) << 16) +
m_baseHashes.charAt(i*2+1);
if (fact.getHash() != match) {
throw new JiBXException("Precompiled base binding '" + m_baseNames[i] + "' has changed since binding '" + getBindingName() + "' was compiled");
} else {
classes.addAll(fact.getBindingClasses());
}
} else {
throw new JiBXException("Classloader conflict for precompiled base binding '" + m_baseNames[i] + "' used by binding '" + getBindingName() + '\'');
}
} catch (IllegalAccessException e) {
ex = e;
} catch (SecurityException e) {
ex = e;
} catch (NoSuchMethodException e) {
ex = e;
} catch (InvocationTargetException e) {
ex = e;
}
if (ex != null) {
throw new JiBXException("Error creating factory for precompiled base binding '" + m_baseNames[i] + "' used by binding '" + getBindingName() + "':" + ex.getMessage());
}
}
}
m_bindingClassesClosure = classes.toArray();
}
m_verified = true;
}
}
/**
* Get the names of the binding factory classes for the separately-compiled
* base bindings used by this binding.
*
* @return binding factory fully-qualified class names
*/
public String[] getBaseBindingFactories() {
return m_bindingFactories;
}
/**
* Get a map from full-qualified binding factory names to an array of
* int values used to convert namespace indexes in that binding
* to this binding. If the binding uses the same namespaces as this binding
* (or a subset of the same namespaces, with the same index values) there is
* no entry in the map.
*
* @return map to namespace index translation
*/
public Map getNamespaceTranslationTableMap() {
return m_bindingNamespaceTables;
}
/**
* Get the namespace prefixes used by the binding.
*
* @return prefixes
*/
public String[] getPrefixes() {
return m_prefixes;
}
/**
* Get the mapping from element local name to class indexes. If a local name
* is only used with a single namespace, the value for that name is an
* Integer giving the index of the class mapped to the name; if
* the local name is used with multiple namespaces, the value for that name
* is an array with multiple int class indexes, for every class
* mapped to the name.
*
* @return map from local name to class index array
*/
public synchronized Map getUnmarshalMap() {
if (m_unmarshalMap == null) {
Map map = new HashMap();
for (int i = 0; i < m_globalNames.length; i++) {
String name = m_globalNames[i];
if (name != null) {
Object value = map.get(name);
if (value instanceof Integer) {
int[] ints = new int[2];
ints[0] = ((Integer)value).intValue();
ints[1] = i;
map.put(name, ints);
} else if (value instanceof int[]) {
int[] olds = (int[])value;
int length = olds.length;
int[] ints = new int[length+1];
System.arraycopy(olds, 0, ints, 0, length);
ints[length] = i;
map.put(name, ints);
} else {
map.put(name, new Integer(i));
}
}
}
m_unmarshalMap = map;
}
return m_unmarshalMap;
}
/**
* Get the marshaller class for a mapping. This can only be used for global
* mappings.
*
* @param index marshaller class index
* @return marshaller class, or null if unable to load class
*/
public Class getMarshallerClass(int index) {
Class clas = m_marshallerClasses[index];
if (clas == null) {
clas = loadClass(m_marshallers[index]);
}
return clas;
}
/**
* Get the unmarshaller class for a mapping. This can only be used for
* global mappings.
*
* @param index unmarshaller class index
* @return unmarshaller class, or null if unable to load class
*/
public Class getUnmarshallerClass(int index) {
Class clas = m_unmarshallerClasses[index];
if (clas == null) {
clas = loadClass(m_unmarshallers[index]);
}
return clas;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/ISO88591StreamWriter.java 0000644 0001750 0001750 00000032171 11065007470 026564 0 ustar twerner twerner /*
Copyright (c) 2004-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
import org.jibx.runtime.IXMLWriter;
/**
* Handler for marshalling text document to a UTF-8 output stream.
*
* @author Dennis M. Sosnoski
*/
public class ISO88591StreamWriter extends StreamWriterBase
{
/**
* Constructor with supplied buffer.
*
* @param uris ordered array of URIs for namespaces used in document (must
* be constant; the value in position 0 must always be the empty string "",
* and the value in position 1 must always be the XML namespace
* "http://www.w3.org/XML/1998/namespace")
*/
public ISO88591StreamWriter(String[] uris) {
super("ISO-8859-1", uris);
try {
defineNamespace(0, "");
defineNamespace(1, "xml");
} catch (IOException e) {
throw new RuntimeException(e.getMessage());
}
}
/**
* Copy constructor. This uses the stream and actual buffer from a supplied
* instance, while setting a new array of namespace URIs. It's intended for
* use when invoking one binding from within another binding.
*
* @param base instance to be used as base for writer
* @param uris ordered array of URIs for namespaces used in document
* (see {@link #ISO88591StreamWriter(String[])})
*/
public ISO88591StreamWriter(ISO88591StreamWriter base, String[] uris) {
super(base, uris);
m_prefixBytes = new byte[uris.length][];
try {
defineNamespace(0, "");
defineNamespace(1, "xml");
} catch (IOException e) {
throw new RuntimeException(e.getMessage());
}
}
/**
* Write markup text to output. Markup text can be written directly to the
* output without the need for any escaping, but still needs to be properly
* encoded.
*
* @param text markup text to be written
* @throws IOException if error writing to document
*/
protected void writeMarkup(String text) throws IOException {
int length = text.length();
makeSpace(length);
int fill = m_fillOffset;
for (int i = 0; i < length; i++) {
char chr = text.charAt(i);
if (chr > 0xFF) {
throw new IOException("Unable to write character code 0x" +
Integer.toHexString(chr) + " in encoding ISO-8859-1");
} else {
m_buffer[fill++] = (byte)chr;
}
}
m_fillOffset = fill;
}
/**
* Write markup character to output. Markup text can be written directly to
* the output without the need for any escaping, but still needs to be
* properly encoded.
*
* @param chr markup character to be written
* @throws IOException if error writing to document
*/
protected void writeMarkup(char chr) throws IOException {
makeSpace(1);
if (chr > 0xFF) {
throw new IOException("Unable to write character code 0x" +
Integer.toHexString(chr) + " in encoding ISO-8859-1");
} else {
m_buffer[m_fillOffset++] = (byte)chr;
}
}
/**
* Report that namespace has been defined.
*
* @param index post-translation namespace URI index number
* @param prefix prefix used for namespace
* @throws IOException if error writing to document
*/
protected void defineNamespace(int index, String prefix)
throws IOException {
byte[] buff;
if (prefix.length() > 0) {
buff = new byte[prefix.length()+1];
for (int i = 0; i < buff.length-1; i++) {
char chr = prefix.charAt(i);
if (chr > 0xFF) {
throw new IOException("Unable to write character code 0x" +
Integer.toHexString(chr) + " in encoding ISO-8859-1");
} else {
buff[i] = (byte)chr;
}
}
buff[buff.length-1] = ':';
} else {
buff = new byte[0];
}
if (index < m_prefixBytes.length) {
m_prefixBytes[index] = buff;
} else if (m_extensionBytes != null) {
index -= m_prefixBytes.length;
for (int i = 0; i < m_extensionBytes.length; i++) {
int length = m_extensionBytes[i].length;
if (index < length) {
m_extensionBytes[i][index] = buff;
} else {
index -= length;
}
}
} else {
throw new IllegalArgumentException("Index out of range");
}
}
/**
* Write attribute text to output. This needs to write the text with any
* appropriate escaping.
*
* @param text attribute value text to be written
* @throws IOException if error writing to document
*/
protected void writeAttributeText(String text) throws IOException {
int length = text.length();
makeSpace(length * 6);
int fill = m_fillOffset;
for (int i = 0; i < length; i++) {
char chr = text.charAt(i);
if (chr == '"') {
fill = writeEntity(m_quotEntityBytes, fill);
} else if (chr == '&') {
fill = writeEntity(m_ampEntityBytes, fill);
} else if (chr == '<') {
fill = writeEntity(m_ltEntityBytes, fill);
} else if (chr == '>' && i > 2 && text.charAt(i-1) == ']' &&
text.charAt(i-2) == ']') {
m_buffer[fill++] = (byte)']';
m_buffer[fill++] = (byte)']';
fill = writeEntity(m_gtEntityBytes, fill);
} else if (chr < 0x20) {
if (chr != 0x9 && chr != 0xA && chr != 0xD) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in attribute value text");
} else {
m_buffer[fill++] = (byte)chr;
}
} else {
if (chr > 0xFF) {
if (chr > 0xD7FF && (chr < 0xE000 || chr == 0xFFFE ||
chr == 0xFFFF || chr > 0x10FFFF)) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) +
" in attribute value text");
} else {
m_fillOffset = fill;
makeSpace(length - i + 8);
fill = m_fillOffset;
m_buffer[fill++] = (byte)'&';
m_buffer[fill++] = (byte)'#';
m_buffer[fill++] = (byte)'x';
for (int j = 12; j >= 0; j -= 4) {
int nib = (chr >> j) & 0xF;
if (nib < 10) {
m_buffer[fill++] = (byte)('0' + nib);
} else {
m_buffer[fill++] = (byte)('A' + nib);
}
}
m_buffer[fill++] = (byte)';';
}
} else {
m_buffer[fill++] = (byte)chr;
}
}
}
m_fillOffset = fill;
}
/**
* Write ordinary character data text content to document.
*
* @param text content value text
* @throws IOException on error writing to document
*/
public void writeTextContent(String text) throws IOException {
flagTextContent();
int length = text.length();
makeSpace(length * 5);
int fill = m_fillOffset;
for (int i = 0; i < length; i++) {
char chr = text.charAt(i);
if (chr == '&') {
fill = writeEntity(m_ampEntityBytes, fill);
} else if (chr == '<') {
fill = writeEntity(m_ltEntityBytes, fill);
} else if (chr == '>' && i > 2 && text.charAt(i-1) == ']' &&
text.charAt(i-2) == ']') {
fill = writeEntity(m_gtEntityBytes, fill);
} else if (chr < 0x20) {
if (chr != 0x9 && chr != 0xA && chr != 0xD) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in content text");
} else {
m_buffer[fill++] = (byte)chr;
}
} else {
if (chr > 0xFF) {
if (chr > 0xD7FF && (chr < 0xE000 || chr == 0xFFFE ||
chr == 0xFFFF || chr > 0x10FFFF)) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) +
" in character data text");
} else {
m_fillOffset = fill;
makeSpace(length - i + 8);
fill = m_fillOffset;
m_buffer[fill++] = (byte)'&';
m_buffer[fill++] = (byte)'#';
m_buffer[fill++] = (byte)'x';
for (int j = 12; j >= 0; j -= 4) {
int nib = (chr >> j) & 0xF;
if (nib < 10) {
m_buffer[fill++] = (byte)('0' + nib);
} else {
m_buffer[fill++] = (byte)('A' + nib);
}
}
m_buffer[fill++] = (byte)';';
}
} else {
m_buffer[fill++] = (byte)chr;
}
}
}
m_fillOffset = fill;
}
/**
* Write CDATA text to document.
*
* @param text content value text
* @throws IOException on error writing to document
*/
public void writeCData(String text) throws IOException {
flagTextContent();
int length = text.length();
makeSpace(length + 12);
int fill = m_fillOffset;
fill = writeEntity(m_cdataStartBytes, fill);
for (int i = 0; i < length; i++) {
char chr = text.charAt(i);
if (chr == '>' && i > 2 && text.charAt(i-1) == ']' &&
text.charAt(i-2) == ']') {
throw new IOException("Sequence \"]]>\" is not allowed " +
"within CDATA section text");
} else if (chr < 0x20) {
if (chr != 0x9 && chr != 0xA && chr != 0xD) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in content text");
} else {
m_buffer[fill++] = (byte)chr;
}
} else {
if (chr > 0xFF) {
throw new IOException("Character code 0x" +
Integer.toHexString(chr) +
" not allowed by encoding in CDATA section text");
} else {
m_buffer[fill++] = (byte)chr;
}
}
}
m_fillOffset = writeEntity(m_cdataEndBytes, fill);
}
/**
* Create a child writer instance to be used for a separate binding. The
* child writer inherits the stream and encoding from this writer, while
* using the supplied namespace URIs.
*
* @param uris ordered array of URIs for namespaces used in document
* (see {@link #ISO88591StreamWriter(String[])})
* @return child writer
* @throws IOException
*/
public IXMLWriter createChildWriter(String[] uris) throws IOException {
flagContent();
return new ISO88591StreamWriter(this, uris);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/XMLWriterBase.java 0000644 0001750 0001750 00000036607 11151767036 025611 0 ustar twerner twerner /*
Copyright (c) 2004-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
import org.jibx.runtime.IExtensibleWriter;
/**
* Base implementation of XML writer interface. This provides common handling of
* indentation and formatting that can be used for all forms of text output.
*
* @author Dennis M. Sosnoski
*/
public abstract class XMLWriterBase extends XMLWriterNamespaceBase
implements IExtensibleWriter
{
/** Flag for current element has text content. */
private boolean m_textSeen;
/** Flag for current element has content. */
private boolean m_contentSeen;
/** Flag for first write done (used to skip indentation before first
element). */
private boolean m_afterFirst;
/**
* Constructor.
*
* @param uris ordered array of URIs for namespaces used in document (must
* be constant; the value in position 0 must always be the empty string "",
* and the value in position 1 must always be the XML namespace
* "http://www.w3.org/XML/1998/namespace")
*/
public XMLWriterBase(String[] uris) {
super(uris);
m_contentSeen = true;
}
/**
* Copy constructor. This initializes the extension namespace information
* from an existing instance.
*
* @param base existing instance
* @param uris ordered array of URIs for namespaces used in document
*/
public XMLWriterBase(XMLWriterBase base, String[] uris) {
super(base, uris);
m_contentSeen = true;
m_afterFirst = base.m_afterFirst;
}
/**
* Write markup text to output. Markup text can be written directly to the
* output without the need for any escaping, but still needs to be properly
* encoded.
*
* @param text markup text to be written
* @throws IOException if error writing to document
*/
protected abstract void writeMarkup(String text) throws IOException;
/**
* Write markup character to output. Markup text can be written directly to
* the output without the need for any escaping, but still needs to be
* properly encoded.
*
* @param chr markup character to be written
* @throws IOException if error writing to document
*/
protected abstract void writeMarkup(char chr) throws IOException;
/**
* Write namespace prefix to output. This internal method is used to throw
* an exception when an undeclared prefix is used.
*
* @param index namespace URI index number
* @throws IOException if error writing to document
*/
protected abstract void writePrefix(int index) throws IOException;
/**
* Write attribute text to output. This needs to write the text with any
* appropriate escaping.
*
* @param text attribute value text to be written
* @throws IOException if error writing to document
*/
protected abstract void writeAttributeText(String text) throws IOException;
/**
* Request output indent with bias from current element nesting level. This
* is used internally for proper indenting in special cases.
*
* @throws IOException on error writing to document
*/
protected abstract void indent(int bias) throws IOException;
/**
* Set up for writing any content to element. If the start tag for the
* element has not been closed, this will close it.
*
* @throws IOException on error writing to document
*/
protected final void flagContent() throws IOException {
if (!m_contentSeen) {
writeMarkup('>');
incrementNesting();
m_contentSeen = true;
}
}
/**
* Set up for writing text content to element. If the start tag for the
* element has not been closed, this will close it.
*
* @throws IOException on error writing to document
*/
protected final void flagTextContent() throws IOException {
flagContent();
m_textSeen = true;
}
/**
* Initialize writer.
*/
public void init() {
}
/**
* Write XML declaration to document. This can only be called before any
* other methods in the interface are called.
*
* @param version XML version text
* @param encoding text for encoding attribute (unspecified if
* null)
* @param standalone text for standalone attribute (unspecified if
* null)
* @throws IOException on error writing to document
*/
public void writeXMLDecl(String version, String encoding, String standalone)
throws IOException {
if (m_afterFirst) {
throw new IllegalStateException
("XML declaration must be written before any other output");
} else {
writeMarkup("");
m_afterFirst = true;
}
}
/**
* Generate open start tag. This allows attributes to be added to the start
* tag, but must be followed by a {@link #closeStartTag} call.
*
* @param index namespace URI index number
* @param name unqualified element name
* @throws IOException on error writing to document
*/
public void startTagOpen(int index, String name) throws IOException {
flagContent();
indentAfterFirst();
writeMarkup('<');
writePrefix(index);
writeMarkup(name);
m_textSeen = m_contentSeen = false;
}
/**
* Generate start tag for element with namespaces. This creates the actual
* start tag, along with any necessary namespace declarations. Previously
* active namespace declarations are not duplicated. The tag is
* left incomplete, allowing other attributes to be added.
*
* @param index namespace URI index number
* @param name element name
* @param nums array of namespace indexes defined by this element (must
* be constant, reference is kept until end of element)
* @param prefs array of namespace prefixes mapped by this element (no
* null values, use "" for default namespace declaration)
* @throws IOException on error writing to document
*/
public void startTagNamespaces(int index, String name,
int[] nums, String[] prefs) throws IOException {
// find the namespaces actually being declared
flagContent();
int[] deltas = openNamespaces(nums, prefs);
// create the start tag for element
startTagOpen(index, name);
// add namespace declarations to open element
for (int i = 0; i < deltas.length; i++) {
int slot = deltas[i];
String prefix = internalNamespacePrefix(slot);
if (prefix != null && prefix.length() > 0) {
writeMarkup(" xmlns:");
writeMarkup(prefix);
writeMarkup("=\"");
} else {
writeMarkup(" xmlns=\"");
}
writeAttributeText(internalNamespaceUri(slot));
writeMarkup('"');
}
}
/**
* Add attribute to current open start tag. This is only valid after a call
* to {@link #startTagOpen} or {@link #startTagNamespaces} and before the
* corresponding call to {@link #closeStartTag}.
*
* @param index namespace URI index number
* @param name unqualified attribute name
* @param value text value for attribute
* @throws IOException on error writing to document
*/
public void addAttribute(int index, String name, String value)
throws IOException {
writeMarkup(' ');
writePrefix(index);
writeMarkup(name);
writeMarkup("=\"");
writeAttributeText(value);
writeMarkup('"');
}
/**
* Close the current open start tag. This is only valid after a call to
* {@link #startTagOpen}.
*
* @throws IOException on error writing to document
*/
public void closeStartTag() throws IOException {
}
/**
* Close the current open start tag as an empty element. This is only valid
* after a call to {@link #startTagOpen}.
*
* @throws IOException on error writing to document
*/
public void closeEmptyTag() throws IOException {
writeMarkup("/>");
incrementNesting();
decrementNesting();
m_contentSeen = true;
}
/**
* Conditionally indent output only if not the first write. This is used
* both to track the output state (useful to check that the XML declaration
* is only written at the start of the document) and to avoid an initial
* blank line in the case where an XML declaration is not written.
*
* @throws IOException on write error
*/
private void indentAfterFirst() throws IOException {
if (m_afterFirst) {
indent(0);
} else {
m_afterFirst = true;
}
}
/**
* Generate closed start tag. No attributes or namespaces can be added to a
* start tag written using this call.
*
* @param index namespace URI index number
* @param name unqualified element name
* @throws IOException on error writing to document
*/
public void startTagClosed(int index, String name) throws IOException {
flagContent();
indentAfterFirst();
writeMarkup('<');
writePrefix(index);
writeMarkup(name);
m_textSeen = m_contentSeen = false;
}
/**
* Generate end tag.
*
* @param index namespace URI index number
* @param name unqualified element name
* @throws IOException on error writing to document
*/
public void endTag(int index, String name) throws IOException {
// first adjust indentation
if (m_contentSeen && !m_textSeen) {
indent(-1);
}
// check for content written to element
if (m_contentSeen) {
// content was written, which means start tag closed and end needed
writeMarkup("');
} else {
// no content, just close start tag as empty tag
writeMarkup("/>");
incrementNesting();
}
// adjust flags for containing element
decrementNesting();
m_textSeen = false;
m_contentSeen = true;
}
/**
* Write comment to document.
*
* @param text comment text
* @throws IOException on error writing to document
*/
public void writeComment(String text) throws IOException {
flagContent();
writeMarkup("");
}
/**
* Write entity reference to document.
*
* @param name entity name
* @throws IOException on error writing to document
*/
public void writeEntityRef(String name) throws IOException {
flagContent();
writeMarkup('&');
writeMarkup(name);
writeMarkup(';');
}
/**
* Write DOCTYPE declaration to document.
*
* @param name root element name
* @param sys system ID (null if none, must be
* non-null for public ID to be used)
* @param pub public ID (null if none)
* @param subset internal subset (null if none)
* @throws IOException on error writing to document
*/
public void writeDocType(String name, String sys, String pub, String subset)
throws IOException {
indentAfterFirst();
writeMarkup("');
}
/**
* Write processing instruction to document.
*
* @param target processing instruction target name
* @param data processing instruction data
* @throws IOException on error writing to document
*/
public void writePI(String target, String data) throws IOException {
flagContent();
indentAfterFirst();
writeMarkup("");
}
/**
* Flush document output. Subclasses must implement this method to force all
* buffered output to be written. To assure proper handling of an open start
* tag they should first call {@link #flagContent()}.
*
* @throws IOException on error writing to document
*/
public abstract void flush() throws IOException;
/**
* Close document output. Completes writing of document output, including
* closing the output medium.
*
* @throws IOException on error writing to document
*/
public abstract void close() throws IOException;
/**
* Reset to initial state for reuse. The writer is serially reusable,
* as long as this method is called to clear any retained state information
* between uses. It is automatically called when output is set.
*/
public void reset() {
m_textSeen = false;
m_contentSeen = true;
m_afterFirst = false;
super.reset();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/BackFillArray.java 0000644 0001750 0001750 00000005044 10270431330 025600 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
/**
* Backfill reference item, used for filling in forward references as
* members of arrays. Each item holds both the array containing the
* reference and the offset in the array.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class BackFillArray implements BackFillReference
{
/** Array containing reference. */
private Object[] m_array;
/** Reference offset within array. */
private int m_index;
/**
* Constructor. Saves the information for filling the reference
* once the associated object is defined.
*
* @param index reference offset within array
* @param array array containing the reference
*/
public BackFillArray(int index, Object[] array) {
m_index = index;
m_array = array;
}
/**
* Define referenced object. This method is called by the framework
* when the forward-referenced item is defined.
*
* @param obj referenced object
*/
public void backfill(Object obj) {
m_array[m_index] = obj;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/GrowableStringArray.java 0000644 0001750 0001750 00000022104 11160702736 027070 0 ustar twerner twerner /*
Copyright (c) 2000-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.lang.reflect.Array;
/**
* Growable String array with type specific access methods. This
* implementation is unsynchronized in order to provide the best possible
* performance for typical usage scenarios, so explicit synchronization must
* be implemented by a wrapper class or directly by the application in cases
* where instances are modified in a multithreaded environment.
*
* @author Dennis M. Sosnoski
*/
public class GrowableStringArray
{
/** Default initial array size. */
public static final int DEFAULT_SIZE = 8;
/** Size of the current array. */
private int m_countLimit;
/** The number of values currently present in the array. */
private int m_countPresent;
/** Maximum size increment for growing array. */
private int m_maximumGrowth;
/** The underlying array used for storing the data. */
private String[] m_baseArray;
/**
* Constructor with full specification.
*
* @param size number of String values initially allowed in
* array
* @param growth maximum size increment for growing array
*/
public GrowableStringArray(int size, int growth) {
String[] array = new String[size];
m_countLimit = size;
m_maximumGrowth = growth;
m_baseArray = array;
}
/**
* Constructor with initial size specified.
*
* @param size number of String values initially allowed in
* array
*/
public GrowableStringArray(int size) {
this(size, Integer.MAX_VALUE);
}
/**
* Default constructor.
*/
public GrowableStringArray() {
this(DEFAULT_SIZE);
}
/**
* Copy (clone) constructor.
*
* @param base instance being copied
*/
public GrowableStringArray(GrowableStringArray base) {
this(base.m_countLimit, base.m_maximumGrowth);
System.arraycopy(base.m_baseArray, 0, m_baseArray, 0,
base.m_countPresent);
m_countPresent = base.m_countPresent;
}
/**
* Copy data after array resize. This just copies the entire contents of the
* old array to the start of the new array. It should be overridden in cases
* where data needs to be rearranged in the array after a resize.
*
* @param base original array containing data
* @param grown resized array for data
*/
private void resizeCopy(Object base, Object grown) {
System.arraycopy(base, 0, grown, 0, Array.getLength(base));
}
/**
* Discards values for a range of indices in the array. Clears references to
* removed values.
*
* @param from index of first value to be discarded
* @param to index past last value to be discarded
*/
private void discardValues(int from, int to) {
for (int i = from; i < to; i++) {
m_baseArray[i] = null;
}
}
/**
* Increase the size of the array to at least a specified size. The array
* will normally be at least doubled in size, but if a maximum size
* increment was specified in the constructor and the value is less than
* the current size of the array, the maximum increment will be used
* instead. If the requested size requires more than the default growth,
* the requested size overrides the normal growth and determines the size
* of the replacement array.
*
* @param required new minimum size required
*/
private void growArray(int required) {
int size = Math.max(required,
m_countLimit + Math.min(m_countLimit, m_maximumGrowth));
String[] grown = new String[size];
resizeCopy(m_baseArray, grown);
m_countLimit = size;
m_baseArray = grown;
}
/**
* Ensure that the array has the capacity for at least the specified
* number of values.
*
* @param min minimum capacity to be guaranteed
*/
public final void ensureCapacity(int min) {
if (min > m_countLimit) {
growArray(min);
}
}
/**
* Overwrite an existing value in the array.
*
* @param index position of value to be overwritten
* @param value value to be added
*/
public void set(int index, String value) {
if (index < m_countPresent) {
m_baseArray[index] = value;
} else {
throw new IllegalArgumentException("Index value out of range");
}
}
/**
* Add a value at the end of the array.
*
* @param value value to be added
*/
public void add(String value) {
int index = getAddIndex();
m_baseArray[index] = value;
}
/**
* Add an array of values at the end of the array.
*
* @param values values to be added
*/
public void addAll(String[] values) {
ensureCapacity(m_countPresent+values.length);
for (int i = 0; i < values.length; i++) {
m_baseArray[m_countPresent++] = values[i];
}
}
/**
* Remove some number of values from the end of the array.
*
* @param count number of values to be removed
* @exception ArrayIndexOutOfBoundsException on attempt to remove more than
* the count present
*/
public void remove(int count) {
int start = m_countPresent - count;
if (start >= 0) {
discardValues(start, m_countPresent);
m_countPresent = start;
} else {
throw new ArrayIndexOutOfBoundsException
("Attempt to remove too many values from array");
}
}
/**
* Get a value from the array.
*
* @param index index of value to be returned
* @return value from stack
* @exception ArrayIndexOutOfBoundsException on attempt to access outside
* valid range
*/
public String get(int index) {
if (m_countPresent > index) {
return m_baseArray[index];
} else {
throw new ArrayIndexOutOfBoundsException
("Attempt to access past end of array");
}
}
/**
* Constructs and returns a simple array containing the same data as held
* in this array.
*
* @return array containing a copy of the data
*/
public String[] toArray() {
String[] copy = new String[m_countPresent];
System.arraycopy(m_baseArray, 0, copy, 0, m_countPresent);
return copy;
}
/**
* Duplicates the object with the generic call.
*
* @return a copy of the object
*/
public Object clone() {
return new GrowableStringArray(this);
}
/**
* Gets the array offset for appending a value to those in the array. If the
* underlying array is full, it is grown by the appropriate size increment
* so that the index value returned is always valid for the array in use by
* the time of the return.
*
* @return index position for added element
*/
private int getAddIndex() {
int index = m_countPresent++;
if (m_countPresent > m_countLimit) {
growArray(m_countPresent);
}
return index;
}
/**
* Get the number of values currently present in the array.
*
* @return count of values present
*/
public int size() {
return m_countPresent;
}
/**
* Check if array is empty.
*
* @return true if array empty, false if not
*/
public boolean isEmpty() {
return m_countPresent == 0;
}
/**
* Set the array to the empty state.
*/
public void clear() {
discardValues(0, m_countPresent);
m_countPresent = 0;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/IXMLReaderFactory.java 0000644 0001750 0001750 00000010505 10434260716 026366 0 ustar twerner twerner /*
Copyright (c) 2005, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.InputStream;
import java.io.Reader;
import org.jibx.runtime.IXMLReader;
import org.jibx.runtime.JiBXException;
/**
* Interface for factories used to create XML reader instances. Instances of
* this interface must be assumed to be single threaded.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public interface IXMLReaderFactory
{
/**
* Get new XML reader instance for document from input stream.
*
* @param is document input stream
* @param name document name (null if unknown)
* @param enc document character encoding (null if unknown)
* @param nsf namespaces enabled flag
* @return new reader instance for document
* @throws JiBXException on parser configuration error
*/
public IXMLReader createReader(InputStream is, String name, String enc,
boolean nsf) throws JiBXException;
/**
* Get new XML reader instance for document from reader.
*
* @param rdr document reader
* @param name document name (null if unknown)
* @param nsf namespaces enabled flag
* @return new reader instance for document
* @throws JiBXException on parser configuration error
*/
public IXMLReader createReader(Reader rdr, String name, boolean nsf)
throws JiBXException;
/**
* Recycle XML reader instance for new document from input stream. If the
* supplied reader can be reused it will be configured for the new document
* and returned; otherwise, a new reader will be created for the document.
* The namespace enabled state of the returned reader is always the same as
* that of the supplied reader.
*
* @param old reader instance to be recycled
* @param is document input stream
* @param name document name (null if unknown)
* @param enc document character encoding (null if unknown)
* @return new reader instance for document
* @throws JiBXException on parser configuration error
*/
public IXMLReader recycleReader(IXMLReader old, InputStream is, String name,
String enc) throws JiBXException;
/**
* Recycle XML reader instance for document from reader. If the supplied
* reader can be reused it will be configured for the new document and
* returned; otherwise, a new reader will be created for the document. The
* namespace enabled state of the returned reader is always the same as that
* of the supplied reader.
*
* @param old reader instance to be recycled
* @param rdr document reader
* @param name document name (null if unknown)
* @return new reader instance for document
* @throws JiBXException on parser configuration error
*/
public IXMLReader recycleReader(IXMLReader old, Reader rdr, String name)
throws JiBXException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/ITrackSourceImpl.java 0000644 0001750 0001750 00000004416 10071714376 026331 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import org.jibx.runtime.ITrackSource;
/**
* Unmarshalling source tracking implementation interface. This interface is
* added to bound classes when requested by the binding definition. It defines
* the method used by JiBX to add unmarshal source tracking information to an
* instance of a bound class.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public interface ITrackSourceImpl extends ITrackSource
{
/**
* Set source document information.
*
* @param name of source document, or null if none
* @param line source document line number, or -1 if unknown
* @param column source document column position, or -1 if
* unknown
*/
public void jibx_setSource(String name, int line, int column);
}
libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/StAXWriter.java 0000644 0001750 0001750 00000030547 11155014054 025157 0 ustar twerner twerner /*
Copyright (c) 2005-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import org.jibx.runtime.IExtensibleWriter;
import org.jibx.runtime.IXMLWriter;
/**
* Writer generating StAX parse event stream output.
*
* @author Dennis M. Sosnoski
*/
public class StAXWriter extends XMLWriterNamespaceBase implements IExtensibleWriter
{
/** Target for parse event stream. */
private XMLStreamWriter m_writer;
/**
* Constructor.
*
* @param uris ordered array of URIs for namespaces used in document (must
* be constant; the value in position 0 must always be the empty string "",
* and the value in position 1 must always be the XML namespace
* "http://www.w3.org/XML/1998/namespace")
*/
public StAXWriter(String[] uris) {
super(uris);
}
/**
* Constructor with writer supplied.
*
* @param uris ordered array of URIs for namespaces used in document (must
* be constant; the value in position 0 must always be the empty string "",
* and the value in position 1 must always be the XML namespace
* "http://www.w3.org/XML/1998/namespace")
* @param wrtr StAX writer for parse event output
*/
public StAXWriter(String[] uris, XMLStreamWriter wrtr) {
this(uris);
m_writer = wrtr;
}
/**
* Copy constructor. This initializes the writer and extension namespace
* information from an existing instance.
*
* @param base existing instance
* @param uris ordered array of URIs for namespaces used in document
*/
public StAXWriter(StAXWriter base, String[] uris) {
super(base, uris);
m_writer = base.m_writer;
}
/**
* Initialize writer.
*/
public void init() {
}
/**
* Set StAX writer.
*
* @param wrtr StAX writer for parse event output
*/
public void setWriter(XMLStreamWriter wrtr) {
m_writer = wrtr;
}
/* (non-Javadoc)
* @see org.jibx.runtime.impl.XMLWriterNamespaceBase#defineNamespace(int, java.lang.String)
*/
protected void defineNamespace(int index, String prefix)
throws IOException {
/* try {
// inform writer of new namespace usage
String uri = getNamespaceUri(index);
if (prefix.length() == 0) {
m_writer.setDefaultNamespace(uri);
} else {
m_writer.setPrefix(prefix, uri);
}
} catch (XMLStreamException e) {
throw new IOException("Error writing to stream: " + e.getMessage());
} */
}
/* (non-Javadoc)
* @see org.jibx.runtime.impl.XMLWriterNamespaceBase#undefineNamespace(int)
*/
protected void undefineNamespace(int index) {}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#setIndentSpaces(int, java.lang.String, char)
*/
public void setIndentSpaces(int count, String newline, char indent) {}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#writeXMLDecl(java.lang.String, java.lang.String, java.lang.String)
*/
public void writeXMLDecl(String version, String encoding, String standalone) throws IOException {
try {
m_writer.writeStartDocument(encoding, version);
} catch (XMLStreamException e) {
throw new IOException("Error writing to stream: " + e.getMessage());
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#startTagOpen(int, java.lang.String)
*/
public void startTagOpen(int index, String name) throws IOException {
try {
// write start element, without or with namespace
if (index == 0) {
m_writer.writeStartElement(name);
} else {
m_writer.writeStartElement(getNamespacePrefix(index), name,
getNamespaceUri(index));
}
// increment nesting for any possible content
incrementNesting();
} catch (XMLStreamException e) {
throw new IOException("Error writing to stream: " + e.getMessage());
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#startTagNamespaces(int, java.lang.String, int[], java.lang.String[])
*/
public void startTagNamespaces(int index, String name, int[] nums,
String[] prefs) throws IOException {
try {
// find the namespaces actually being declared
int[] deltas = openNamespaces(nums, prefs);
// open the start tag
startTagOpen(index, name);
// write the namespace declarations
for (int i = 0; i < deltas.length; i++) {
int slot = deltas[i];
String prefix = internalNamespacePrefix(slot);
String uri = internalNamespaceUri(slot);
if (prefix.length() > 0) {
m_writer.writeNamespace(prefix, uri);
} else {
m_writer.writeDefaultNamespace(uri);
}
}
} catch (XMLStreamException e) {
throw new IOException("Error writing to stream: " + e.getMessage());
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#addAttribute(int, java.lang.String, java.lang.String)
*/
public void addAttribute(int index, String name, String value)
throws IOException {
try {
if (index == 0) {
m_writer.writeAttribute(name, value);
} else {
m_writer.writeAttribute(getNamespacePrefix(index),
getNamespaceUri(index), name, value);
}
} catch (XMLStreamException e) {
throw new IOException("Error writing to stream: " + e.getMessage());
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#closeStartTag()
*/
public void closeStartTag() throws IOException {
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#closeEmptyTag()
*/
public void closeEmptyTag() throws IOException {
try {
m_writer.writeEndElement();
decrementNesting();
} catch (XMLStreamException e) {
throw new IOException("Error writing to stream: " + e.getMessage());
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#startTagClosed(int, java.lang.String)
*/
public void startTagClosed(int index, String name) throws IOException {
startTagOpen(index, name);
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#endTag(int, java.lang.String)
*/
public void endTag(int index, String name) throws IOException {
// not valid approach in general, but okay for StAX case
closeEmptyTag();
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#writeTextContent(java.lang.String)
*/
public void writeTextContent(String text) throws IOException {
try {
m_writer.writeCharacters(text);
} catch (XMLStreamException e) {
throw new IOException("Error writing to stream: " + e.getMessage());
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#writeCData(java.lang.String)
*/
public void writeCData(String text) throws IOException {
try {
m_writer.writeCData(text);
} catch (XMLStreamException e) {
throw new IOException("Error writing to stream: " + e.getMessage());
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#writeComment(java.lang.String)
*/
public void writeComment(String text) throws IOException {
try {
m_writer.writeComment(text);
} catch (XMLStreamException e) {
throw new IOException("Error writing to stream: " + e.getMessage());
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#writeEntityRef(java.lang.String)
*/
public void writeEntityRef(String name) throws IOException {
try {
m_writer.writeEntityRef(name);
} catch (XMLStreamException e) {
throw new IOException("Error writing to stream: " + e.getMessage());
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#writeDocType(java.lang.String, java.lang.String, java.lang.String, java.lang.String)
*/
public void writeDocType(String name, String sys, String pub, String subset)
throws IOException {
try {
StringBuffer buff = new StringBuffer();
buff.append("');
m_writer.writeDTD(buff.toString());
} catch (XMLStreamException e) {
throw new IOException("Error writing to stream: " + e.getMessage());
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#writePI(java.lang.String, java.lang.String)
*/
public void writePI(String target, String data) throws IOException {
try {
m_writer.writeProcessingInstruction(target, data);
} catch (XMLStreamException e) {
throw new IOException("Error writing to stream: " + e.getMessage());
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#indent()
*/
public void indent() throws IOException {}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#flush()
*/
public void flush() throws IOException {
// internal flush only, do not pass through to writer
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLWriter#close()
*/
public void close() throws IOException {
try {
m_writer.close();
} catch (XMLStreamException e) {
throw new IOException("Error closing stream: " + e.getMessage());
}
}
/**
* Create a child writer instance to be used for a separate binding. The
* child writer inherits the output handling from this writer, while using
* the supplied namespace URIs.
*
* @param uris ordered array of URIs for namespaces used in document
* (see {@link #StAXWriter(String[])})
* @return child writer
*/
public IXMLWriter createChildWriter(String[] uris) {
return new StAXWriter(this, uris);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/XMLWriterNamespaceBase.java 0000644 0001750 0001750 00000052640 11525770152 027417 0 ustar twerner twerner /*
Copyright (c) 2004-2011, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
import java.util.Stack;
import org.jibx.runtime.IXMLWriter;
/**
* Base implementation of XML writer interface namespace handling. This tracks
* only the namespace declarations and the element nesting depth. It can be used
* as a base class for all forms of output.
*
* @author Dennis M. Sosnoski
*/
public abstract class XMLWriterNamespaceBase implements IXMLWriter
{
/** Empty array for default return. */
private static final int[] EMPTY_INT_ARRAY = new int[0];
/** URIs for namespaces. */
protected String[] m_uris;
/** Prefixes currently defined for namespaces. */
protected String[] m_prefixes;
/** Depth of nested tags. */
private int m_nestingDepth;
/** Stack of information for namespace declarations. */
private Stack m_namespaceStack;
/** Depth of top namespace declaration level. */
private int m_namespaceDepth;
/** Extension namespace URIs (null if not in use). */
private String[][] m_extensionUris;
/** Extension namespace prefixes (null if not in use). */
private String[][] m_extensionPrefixes;
/** Current namespace translation table (null if none). */
private int[] m_translateTable;
/** Stack of namespace translation tables in use. */
private Stack m_translateTableStack;
/**
* Constructor.
*
* @param uris ordered array of URIs for namespaces used in document (must
* be constant; the value in position 0 must always be the empty string "",
* and the value in position 1 must always be the XML namespace
* "http://www.w3.org/XML/1998/namespace")
*/
public XMLWriterNamespaceBase(String[] uris) {
m_uris = uris;
m_prefixes = new String[uris.length];
m_prefixes[0] = "";
m_prefixes[1] = "xml";
m_namespaceStack = new Stack();
m_namespaceDepth = -1;
m_translateTableStack = new Stack();
}
/**
* Copy constructor. This initializes the extension namespace information
* from an existing instance.
*
* @param base existing instance
* @param uris ordered array of URIs for namespaces used in document
*/
public XMLWriterNamespaceBase(XMLWriterNamespaceBase base, String[] uris) {
this(uris);
m_extensionUris = base.m_extensionUris;
m_extensionPrefixes = base.m_extensionPrefixes;
m_nestingDepth = base.m_nestingDepth;
}
/**
* Report to subclass that namespace has been defined.
*
* @param index post-translation namespace URI index number
* @param prefix prefix used for namespace
* @throws IOException if error writing to document
*/
protected abstract void defineNamespace(int index, String prefix)
throws IOException;
/**
* Report to subclass that namespace has been undefined.
*
* @param index post-translation namespace URI index number
*/
protected abstract void undefineNamespace(int index);
/**
* Set namespace URIs. It is provided so that subclasses can implement easy
* reuse.
*
* @param uris ordered array of URIs for namespaces used in document
*/
protected void internalSetUris(String[] uris) {
m_uris = uris;
m_prefixes = new String[uris.length];
m_prefixes[0] = "";
m_prefixes[1] = "xml";
}
/**
* Set prefix for namespace.
*
* @param index post-translation namespace URI index number
* @param prefix
*/
private void setNamespacePrefix(int index, String prefix) {
if (index < m_prefixes.length) {
m_prefixes[index] = prefix;
} else if (m_extensionUris != null) {
index -= m_prefixes.length;
for (int i = 0; i < m_extensionUris.length; i++) {
int length = m_extensionUris[i].length;
if (index < length) {
m_extensionPrefixes[i][index] = prefix;
break;
} else {
index -= length;
}
}
}
}
/**
* Open the specified namespaces. Previously active namespace declarations
* are not duplicated.
*
* @param nums array of namespace indexes defined by this element (reference
* kept until namespaces are closed, values may be modified by this method)
* @param prefs array of namespace prefixes mapped by this element (no
* null values, use "" for default namespace declaration)
* @return array of translated indexes for namespaces not previously active
* (the ones actually needing to be declared, in the case of text output)
* @throws IOException on error writing to document
*/
public int[] openNamespaces(int[] nums, String[] prefs) throws IOException {
// find the number of namespaces actually being declared
int count = 0;
loop: for (int i = 0; i < nums.length; i++) {
// set prefix only if different and not changing prefix to default
String newpref = prefs[i];
String oldpref = getNamespacePrefix(nums[i]);
boolean use = false;
if (!newpref.equals(oldpref) &&
(!"".equals(newpref) || oldpref == null)) {
use = true;
for (int j = 0; j < i; j++) {
if (nums[i] == nums[j]) {
if ("".equals(newpref)) {
// ignore replacing prefix with default in same call
use = false;
break;
} else {
// multiple prefixes for namespace, keep only last
nums[j] = -1;
continue loop;
}
}
}
}
if (use) {
count++;
} else {
nums[i] = -1;
}
}
// check if there's actually any change
int[] deltas = EMPTY_INT_ARRAY;
if (count > 0) {
// get the set of namespace indexes that are changing
String[] priors = new String[count];
if (count == nums.length) {
// replace the full set, tracking the prior values
deltas = nums;
if (m_translateTable != null) {
for (int i = 0; i < deltas.length; i++) {
deltas[i] = m_translateTable[deltas[i]];
}
}
for (int i = 0; i < count; i++) {
int slot = deltas[i];
priors[i] = getNamespacePrefix(slot);
setNamespacePrefix(slot, prefs[i]);
defineNamespace(slot, prefs[i]);
}
} else {
// replace only changed ones, tracking both indexes and priors
int fill = 0;
deltas = new int[count];
for (int i = 0; i < nums.length; i++) {
int slot = nums[i];
if (slot >= 0) {
int xlate = translateNamespace(slot);
deltas[fill] = xlate;
priors[fill++] = getNamespacePrefix(slot);
setNamespacePrefix(xlate, prefs[i]);
defineNamespace(xlate, prefs[i]);
}
}
}
// set up for undeclaring namespaces on close of element
m_namespaceStack.push
(new DeclarationInfo(m_nestingDepth, deltas, priors));
m_namespaceDepth = m_nestingDepth;
}
return deltas;
}
/**
* Ends the current innermost set of nested namespace definitions. Reverts
* the namespaces involved to their previously-declared prefixes, and sets
* up for ending the new innermost set.
*/
private void closeNamespaces() {
// revert prefixes for namespaces included in last declaration
DeclarationInfo info = (DeclarationInfo)m_namespaceStack.pop();
int[] deltas = info.m_deltas;
String[] priors = info.m_priors;
for (int i = deltas.length - 1; i >= 0; i--) {
int index = deltas[i];
undefineNamespace(index);
if (index < m_prefixes.length) {
m_prefixes[index] = priors[i];
} else if (m_extensionUris != null) {
index -= m_prefixes.length;
for (int j = 0; j < m_extensionUris.length; j++) {
int length = m_extensionUris[j].length;
if (index < length) {
m_extensionPrefixes[j][index] = priors[i];
} else {
index -= length;
}
}
}
}
// set up for clearing next nested set
if (m_namespaceStack.empty()) {
m_namespaceDepth = -1;
} else {
m_namespaceDepth =
((DeclarationInfo)m_namespaceStack.peek()).m_depth;
}
}
/**
* Get the current element nesting depth. Elements are only counted in the
* depth returned when they're officially open - after the start tag has
* been output and before the end tag has been output.
*
* @return number of nested elements at current point in output
*/
public final int getNestingDepth() {
return m_nestingDepth;
}
/**
* Get the number of namespaces currently defined. This is equivalent to the
* index of the next extension namespace added.
*
* @return namespace count
*/
public final int getNamespaceCount() {
int count = m_uris.length;
if (m_extensionUris != null) {
for (int i = 0; i < m_extensionUris.length; i++) {
count += m_extensionUris[i].length;
}
}
return count;
}
/**
* Increment the current nesting depth. Subclasses need to call this method
* whenever an element start tag is written.
*/
protected void incrementNesting() {
m_nestingDepth++;
}
/**
* Decrement the current nesting depth. Subclasses need to call this method
* whenever an element end tag is written.
*/
protected void decrementNesting() {
--m_nestingDepth;
if (m_nestingDepth >= 0) {
while (m_nestingDepth == m_namespaceDepth) {
closeNamespaces();
}
}
}
/**
* Reset to initial state for reuse. Subclasses overriding this method need
* to call this base class implementation during their processing.
*/
public void reset() {
m_nestingDepth = 0;
m_namespaceDepth = -1;
m_namespaceStack.clear();
m_prefixes = new String[m_uris.length];
m_prefixes[0] = "";
m_prefixes[1] = "xml";
m_extensionUris = null;
m_extensionPrefixes = null;
m_translateTable = null;
m_translateTableStack.clear();
}
/**
* Get namespace URIs for mapping. This gets the full ordered array of
* namespaces known in the binding used for this marshalling, where the
* index number of each namespace URI is the namespace index used to lookup
* the prefix when marshalling a name in that namespace. The returned array
* must not be modified.
*
* @return array of namespaces
*/
public final String[] getNamespaces() {
return m_uris;
}
/**
* Get URI for translated namespace index.
*
* @param index namespace URI index number (post-translation)
* @return namespace URI text, or null if the namespace index
* is invalid
*/
protected final String internalNamespaceUri(int index) {
if (index < m_uris.length) {
return m_uris[index];
} else if (m_extensionUris != null) {
index -= m_uris.length;
for (int i = 0; i < m_extensionUris.length; i++) {
int length = m_extensionUris[i].length;
if (index < length) {
return m_extensionUris[i][index];
} else {
index -= length;
}
}
}
return null;
}
/**
* Get URI for namespace.
*
* @param index namespace URI index number
* @return namespace URI text, or null if the namespace index
* is invalid
*/
public final String getNamespaceUri(int index) {
return internalNamespaceUri(translateNamespace(index));
}
/**
* Get current prefix defined for translated namespace index.
*
* @param index namespace URI index number (post-translation)
* @return current prefix text, or null if the namespace is not
* currently mapped
*/
protected final String internalNamespacePrefix(int index) {
if (index < m_prefixes.length) {
return m_prefixes[index];
} else if (m_extensionUris != null) {
index -= m_prefixes.length;
for (int i = 0; i < m_extensionUris.length; i++) {
int length = m_extensionUris[i].length;
if (index < length) {
return m_extensionPrefixes[i][index];
} else {
index -= length;
}
}
}
return null;
}
/**
* Get current prefix defined for namespace.
*
* @param index namespace URI index number
* @return current prefix text, or null if the namespace is not
* currently mapped
*/
public final String getNamespacePrefix(int index) {
return internalNamespacePrefix(translateNamespace(index));
}
/**
* Get index of namespace mapped to prefix. If namespace translation is in
* use, the returned index will be the value prior to translation. This can
* be an expensive operation (regardless of whether translation is used or
* not) with time proportional to the number of namespaces defined, so it
* should be used with care.
*
* @param prefix text to match (non-null, use "" for default
* prefix)
* @return index namespace URI index number mapped to prefix
*/
public final int getPrefixIndex(String prefix) {
if (m_extensionPrefixes != null) {
for (int i = m_extensionPrefixes.length-1; i >= 0; i--) {
String[] prefixes = m_extensionPrefixes[i];
for (int j = prefixes.length-1; j >= 0; j--) {
if (prefix.equals(prefixes[j])) {
int index = j + m_prefixes.length;
for (int k = i-1; k >= 0; k--) {
index += m_extensionPrefixes[k].length;
}
return index;
}
}
}
}
if (m_translateTable == null) {
for (int i = m_prefixes.length-1; i >= 0; i--) {
if (prefix.equals(m_prefixes[i])) {
return i;
}
}
} else {
for (int i = m_translateTable.length-1; i >= 0; i--) {
int xlate = m_translateTable[i];
if (prefix.equals(m_prefixes[xlate])) {
return xlate;
}
}
}
return -1;
}
/**
* Grow array of array of strings.
*
* @param base array to be grown (null is treated as zero
* length)
* @param items array of strings to be added at end of base array
* @return array with added array of items
*/
protected static String[][] growArray(String[][] base, String[] items) {
if (base == null) {
return new String[][] { items };
} else {
int length = base.length;
String[][] grow = new String[length+1][];
System.arraycopy(base, 0, grow, 0, length);
grow[length] = items;
return grow;
}
}
/**
* Shrink array of array of strings.
*
* @param base array to be shrunk
* @return array with last set of items eliminated (null if
* empty)
*/
protected static String[][] shrinkArray(String[][] base) {
int length = base.length;
if (length == 1) {
return null;
} else {
String[][] shrink = new String[length-1][];
System.arraycopy(base, 0, shrink, 0, length-1);
return shrink;
}
}
/**
* Append extension namespace URIs to those in mapping.
*
* @param uris namespace URIs to extend those in mapping
*/
public void pushExtensionNamespaces(String[] uris) {
m_extensionUris = growArray(m_extensionUris, uris);
m_extensionPrefixes =
growArray(m_extensionPrefixes, new String[uris.length]);
}
/**
* Remove extension namespace URIs. This removes the last set of
* extension namespaces pushed using {@link #pushExtensionNamespaces}.
*/
public void popExtensionNamespaces() {
m_extensionUris = shrinkArray(m_extensionUris);
m_extensionPrefixes = shrinkArray(m_extensionPrefixes);
}
/**
* Get extension namespace URIs added to those in mapping. This gets the
* current set of extension definitions. The returned arrays must not be
* modified.
*
* @return array of arrays of extension namespaces (null if
* none)
*/
public final String[][] getExtensionNamespaces() {
return m_extensionUris;
}
/**
* Translate a namespace index number to match internal tables.
*
* @param index raw namespace index
* @return namespace index number for internal tables
*/
public int translateNamespace(int index) {
if (m_translateTable != null && index < m_translateTable.length) {
return m_translateTable[index];
} else {
return index;
}
}
/**
* Push a translation table to be used for converting namespace index
* numbers passed as arguments to values used for internal lookup. This
* allows a layer of indirection between the client code and the
* namespace definitions, designed for use in supporting precompiled
* bindings. The translated values must match the internal tables.
*
* @param table translation table to be used (null if no
* change)
*/
public void pushTranslationTable(int[] table) {
m_translateTableStack.push(m_translateTable);
if (table != null) {
m_translateTable = table;
}
}
/**
* Pop a translation table used for converting namespace index numbers to
* values matching the internal lookup.
*/
public void popTranslationTable() {
m_translateTable = (int[])m_translateTableStack.pop();
}
/**
* Namespace declaration tracking information. This tracks all information
* associated with an element that declares namespaces.
*/
private static class DeclarationInfo
{
/** Depth of element making declaration. */
public final int m_depth;
/** Indexes of namespaces included in declarations. */
public final int[] m_deltas;
/** Prior prefixes for namespaces. */
public final String[] m_priors;
/** Simple constructor. */
public DeclarationInfo(int depth, int[] deltas, String[] priors) {
m_depth = depth;
m_deltas = deltas;
m_priors = priors;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/BackFillHolder.java 0000644 0001750 0001750 00000006202 10071714370 025743 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.util.ArrayList;
/**
* Holder used to collect forward references to a particular object. The
* references are processed when the object is defined.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class BackFillHolder
{
/** Expected class name of tracked object. */
private String m_class;
/** List of references to this object. */
private ArrayList m_list;
/**
* Constructor. Just creates the backing list.
*
* @param name expected class name of tracked object
*/
public BackFillHolder(String name) {
m_class = name;
m_list = new ArrayList();
}
/**
* Add forward reference to tracked object. This method is called by
* the framework when a reference item is created for the object
* associated with this holder.
*
* @param ref backfill reference item
*/
public void addBackFill(BackFillReference ref){
m_list.add(ref);
}
/**
* Define referenced object. This method is called by the framework
* when the forward-referenced object is defined, and in turn calls each
* reference to fill in the reference.
*
* @param obj referenced object
*/
public void defineValue(Object obj) {
for (int i = 0; i < m_list.size(); i++) {
BackFillReference ref = (BackFillReference)m_list.get(i);
ref.backfill(obj);
}
}
/**
* Get expected class name of referenced object.
*
* @return expected class name of referenced object
*/
public String getExpectedClass() {
return m_class;
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/GenericXMLWriter.java 0000644 0001750 0001750 00000025533 11053531610 026273 0 ustar twerner twerner /*
Copyright (c) 2004-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
import java.io.Writer;
import org.jibx.runtime.ICharacterEscaper;
import org.jibx.runtime.IXMLWriter;
/**
* Generic handler for marshalling text document to a writer. This is the
* most general output handler since it can be used with any character encoding
* and and output writer.
*
* @author Dennis M. Sosnoski
*/
public class GenericXMLWriter extends XMLWriterBase
{
/** Writer for text output. */
private Writer m_writer;
/** Escaper for character data content output. */
private ICharacterEscaper m_escaper;
/** Indent tags for pretty-printed text. */
private boolean m_indent;
/** Base number of characters in indent sequence (end of line only). */
private int m_indentBase;
/** Number of extra characters in indent sequence per level of nesting. */
private int m_indentPerLevel;
/** Raw text for indentation sequences. */
private char[] m_indentSequence;
/**
* Constructor.
*
* @param uris ordered array of URIs for namespaces used in document (must
* be constant; the value in position 0 must always be the empty string "",
* and the value in position 1 must always be the XML namespace
* "http://www.w3.org/XML/1998/namespace")
*/
public GenericXMLWriter(String[] uris) {
super(uris);
}
/**
* Copy constructor. This takes the writer from a supplied instance, while
* setting a new array of namespace URIs. It's intended for use when
* invoking one binding from within another binding.
*
* @param base instance to be used as base for writer
* @param uris ordered array of URIs for namespaces used in document
* (see {@link #GenericXMLWriter(String[])})
*/
public GenericXMLWriter(GenericXMLWriter base, String[] uris) {
super(base, uris);
setOutput(base.m_writer, base.m_escaper);
m_indent = base.m_indent;
m_indentBase = base.m_indentBase;
m_indentPerLevel = base.m_indentPerLevel;
m_indentSequence = base.m_indentSequence;
}
/**
* Set output writer and escaper. If an output writer is currently open when
* this is called the existing writer is flushed and closed, with any
* errors ignored.
*
* @param outw writer for document data output
* @param escaper character escaper for chosen encoding
*/
public void setOutput(Writer outw, ICharacterEscaper escaper) {
try {
close();
} catch (IOException e) { /* deliberately empty */ }
m_writer = outw;
m_escaper = escaper;
reset();
}
/**
* Set nesting indentation. This is advisory only, and implementations of
* this interface are free to ignore it. The intent is to indicate that the
* generated output should use indenting to illustrate element nesting.
*
* @param count number of character to indent per level, or disable
* indentation if negative (zero means new line only)
* @param newline sequence of characters used for a line ending
* (null means use the single character '\n')
* @param indent whitespace character used for indentation
*/
public void setIndentSpaces(int count, String newline, char indent) {
if (count >= 0) {
if (newline == null) {
newline = "\n";
}
m_indent = true;
m_indentBase = newline.length();
m_indentPerLevel = count;
int length = newline.length() + count * 10;
m_indentSequence = new char[length];
for (int i = 0; i < length; i++) {
if (i < newline.length()) {
m_indentSequence[i] = newline.charAt(i);
} else {
m_indentSequence[i] = indent;
}
}
} else {
m_indent = false;
}
}
/**
* Write markup text to output. Markup text can be written directly to the
* output without the need for any escaping.
*
* @param text markup text to be written
* @throws IOException if error writing to document
*/
protected void writeMarkup(String text) throws IOException {
m_writer.write(text);
}
/**
* Write markup character to output. Markup text can be written directly to
* the output without the need for any escaping.
*
* @param chr markup character to be written
* @throws IOException if error writing to document
*/
protected void writeMarkup(char chr) throws IOException {
m_writer.write(chr);
}
/**
* Report that namespace has been defined.
*
* @param index post-translation namespace URI index number
* @param prefix prefix used for namespace
*/
protected void defineNamespace(int index, String prefix) {}
/**
* Report that namespace has been undefined.
*
* @param index post-translation namespace URI index number
*/
protected void undefineNamespace(int index) {}
/**
* Write namespace prefix to output. This internal method is used to handle
* translation of namespace indexes to internal form, and also to throw an
* exception when an undeclared prefix is used.
*
* @param index namespace URI index number
* @throws IOException if error writing to document
*/
protected void writePrefix(int index) throws IOException {
try {
String text = getNamespacePrefix(index);
if (text.length() > 0) {
m_writer.write(text);
m_writer.write(':');
}
} catch (NullPointerException ex) {
throw new IOException("Namespace URI has not been declared.");
}
}
/**
* Write attribute text to output. This needs to write the text with any
* appropriate escaping.
*
* @param text attribute value text to be written
* @throws IOException if error writing to document
*/
protected void writeAttributeText(String text) throws IOException {
m_escaper.writeAttribute(text, m_writer);
}
/**
* Write ordinary character data text content to document. This needs to
* write the text with any appropriate escaping.
*
* @param text content value text
* @throws IOException on error writing to document
*/
public void writeTextContent(String text) throws IOException {
flagTextContent();
m_escaper.writeContent(text, m_writer);
}
/**
* Write CDATA text to document. This needs to write the text with any
* appropriate escaping.
*
* @param text content value text
* @throws IOException on error writing to document
*/
public void writeCData(String text) throws IOException {
flagTextContent();
m_escaper.writeCData(text, m_writer);
}
/**
* Request output indent. Output the line end sequence followed by the
* appropriate number of indent characters.
*
* @param bias indent depth difference (positive or negative) from current
* element nesting depth
* @throws IOException on error writing to document
*/
public void indent(int bias) throws IOException {
if (m_indent) {
flagContent();
int length = m_indentBase +
(getNestingDepth() + bias) * m_indentPerLevel;
if (length > m_indentSequence.length) {
int use = Math.max(length,
m_indentSequence.length*2 - m_indentBase);
char[] grow = new char[use];
System.arraycopy(m_indentSequence, 0, grow, 0,
m_indentSequence.length);
for (int i = m_indentSequence.length; i < use; i++) {
grow[i] = grow[m_indentBase];
}
m_indentSequence = grow;
}
m_writer.write(m_indentSequence, 0, length);
}
}
/**
* Request output indent. Output the line end sequence followed by the
* appropriate number of indent characters for the current nesting level.
*
* @throws IOException on error writing to document
*/
public void indent() throws IOException {
indent(0);
}
/**
* Flush document output. Forces out all output generated to this point.
*
* @throws IOException on error writing to document
*/
public void flush() throws IOException {
// internal flush only, do not pass through to writer
flagContent();
}
/**
* Close document output. Completes writing of document output, including
* closing the output medium.
*
* @throws IOException on error writing to document
*/
public void close() throws IOException {
flush();
if (m_writer != null) {
m_writer.close();
m_writer = null;
}
}
/**
* Create a child writer instance to be used for a separate binding. The
* child writer inherits the stream and encoding from this writer, while
* using the supplied namespace URIs.
*
* @param uris ordered array of URIs for namespaces used in document
* (see {@link #GenericXMLWriter(String[])})
* @return child writer
*/
public IXMLWriter createChildWriter(String[] uris) {
return new GenericXMLWriter(this, uris);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/InByteBuffer.java 0000644 0001750 0001750 00000016360 11177644344 025503 0 ustar twerner twerner /*
Copyright (c) 2008-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
import java.io.InputStream;
/**
* Byte buffer wrapping an input stream. Clients need to obey the interface
* access rules.
*
* @author Dennis M. Sosnoski
*/
public class InByteBuffer implements IInByteBuffer
{
/** Default input buffer size. */
public static final int DEFAULT_BUFFER_SIZE = 4096;
/** Stream for byte input. */
private InputStream m_stream;
/** Flag for end of stream reached. */
private boolean m_isEnd;
/** Buffer for input bytes. */
private byte[] m_buffer;
/** Offset past end of bytes in buffer. */
private int m_limit;
/** Current offset for removing bytes from buffer. */
private int m_offset;
/**
* Constructor with size specified.
*
* @param size initial buffer size in bytes
*/
public InByteBuffer(int size) {
m_buffer = new byte[size];
}
/**
* Constructor using default buffer size.
*/
public InByteBuffer() {
this(DEFAULT_BUFFER_SIZE);
}
/**
* Read data into the buffer to assure at least a minimum number of bytes
* are available. Any retained data is first copied down to the start of the
* buffer array. Next, data is read from the wrapped stream into the
* available space in the buffer. The actual number of characters read by a
* call to this method is normally between one and the space available in
* the buffer array.
*
* @param size minimum number of bytes required
* @return true if data has been read into buffer,
* false if not
* @throws IOException on error reading from wrapped stream
*/
private boolean fillBuffer(int size) throws IOException {
if (m_isEnd) {
return false;
} else {
// first check for new buffer needed
byte[] oldbuf = m_buffer;
if (m_buffer.length < size) {
byte[] newbuf = new byte[Math.max(size, m_buffer.length*2)];
m_buffer = newbuf;
}
// copy any remaining data to start of buffer
int rem = m_limit - m_offset;
if (rem > 0 && (m_offset > 0 || m_buffer != oldbuf)) {
System.arraycopy(oldbuf, m_offset, m_buffer, 0, rem);
}
m_offset = 0;
// read to at least the required number of bytes
m_limit = rem;
while (m_limit < size) {
int max = m_buffer.length - m_limit;
int actual = m_stream.read(m_buffer, m_limit, max);
if (actual >= 0) {
m_limit += actual;
} else {
m_isEnd = true;
return false;
}
}
return true;
}
}
/**
* Reset to initial state for reuse.
*/
public void reset() {
m_isEnd = false;
m_limit = 0;
m_offset = 0;
m_stream = null;
}
/**
* Set the actual input stream to be used for this buffer. If an input
* stream is currently open when this is called the existing stream is
* closed and any buffered data discarded, with any errors ignored.
*
* @param is stream
*/
public void setInput(InputStream is) {
try {
finish();
} catch (IOException e) { /* deliberately empty */ }
reset();
m_stream = is;
}
//
// IInByteBuffer implementation
/**
* Get the byte array buffer.
*
* @return array
*/
public byte[] getBuffer() {
return m_buffer;
}
/**
* Get the index of the next byte to be read. After reading data, the {@link
* #setOffset(int)} method must be used to update the current offset before
* any other operations are performed on the buffer.
*
* @return offset
*/
public int getOffset() {
return m_offset;
}
/**
* Set the current offset. This must be used to update the stored buffer
* state after reading any data.
*
* @param offset
*/
public void setOffset(int offset) {
m_offset = offset;
}
/**
* Get offset past the end of data in buffer.
*
* @return offset past end of data
*/
public int getLimit() {
return m_limit;
}
/**
* Require some number of bytes of data. When this call is made the buffer
* can discard all data up to the current offset, and will copy retained
* data down to the start of the buffer array and read more data from the
* input stream if necessary to make the requested number of bytes
* available. This call may cause the byte array buffer to be replaced, so
* {@link #getBuffer()}, {@link #getLimit()}, and {@link #getOffset()} must
* all be called again before any further use of the buffer.
*
* @param size desired number of bytes
* @return true if request satisfied, false if not
* @throws IOException
*/
public boolean require(int size) throws IOException {
if (m_limit - m_offset < size) {
return fillBuffer(size);
} else {
return true;
}
}
/**
* Complete usage of the current stream. This method should be called
* whenever the application is done reading from the buffered stream. Once
* this method is called, a call to {@link #setInput(InputStream)} is
* required before the buffer can again be used.
*
* @throws IOException
*/
public void finish() throws IOException {
if (m_stream != null) {
m_stream.close();
m_stream = null;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/IOutByteBuffer.java 0000644 0001750 0001750 00000006337 11066266232 026011 0 ustar twerner twerner /*
Copyright (c) 2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
/**
* Output buffer interface. This extends the basic byte array buffer interface
* with methods specifically for output. Client code needs to obey the access
* rules stated in the method documentation, including the documentation for the
* base interface methods.
*
* @author Dennis M. Sosnoski
*/
public interface IOutByteBuffer extends IByteBuffer
{
/**
* Free at least some number of bytes of space in the byte array. If no
* reserve is specified, this call may write all data up to the current
* offset to the output stream, and if necessary will replace the byte array
* with a larger array. If a reserve is specified, only data up to the
* reserve will be written, and any remaining data will be moved down to the
* start of the (possibly new) byte array on return. Both {@link
* #getBuffer()} and {@link IByteBuffer#getOffset()} must always be called
* again before any further use of the buffer.
*
* @param reserve offset of data to be preserved in buffer (nothing
* preserved if greater than or equal to current offset)
* @param size desired number of bytes
* @throws IOException
*/
void free(int reserve, int size) throws IOException;
/**
* Empty the buffer. Writes all data from the buffer to the output stream,
* resetting the offset to the logical start of the buffer (which may not be
* offset zero, since implementations may add some sort of header). This
* method is guaranteed not to replace the byte array, but
* {@link IByteBuffer#getOffset()} must always be called again before any
* further use of the buffer.
*
* @throws IOException
*/
void flush() throws IOException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/package.html 0000644 0001750 0001750 00000001113 10071714422 024546 0 ustar twerner twerner
JiBX data binding framework runtime implementation package. These classes are
designed for use in generated code by the binding generator portion of the framework.
They are not generally intended for direct use by end users, and are subject
to more change than the published external APIs.
The only circumstance in which an end user of the framework should need to work
with these classes is when writing a marshaller or unmarshaller for a class.
These replace generated code for the classes involved, and hence allow full
control over the operation of the framework.
libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/RuntimeSupport.java 0000644 0001750 0001750 00000026602 11260446026 026165 0 ustar twerner twerner /*
Copyright (c) 2007-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.Utility;
/**
* Support class providing methods used by generated code and binding factory
* initialization.
*
* @author Dennis M. Sosnoski
*/
public abstract class RuntimeSupport
{
/**
* Split concatenated class or method names string into an array of
* fully-qualified individual class and/or method names. This is used by the
* binding factory initialization, so that arrays of class and method names
* can be represented efficiently in the generated code. It takes as input a
* string consisting of compacted fully-qualified class names separated by
* '|' delimiter characters. If the compacted name starts with one or more
* '.' or '$' characters the corresponding number of package and class name
* levels are copied from the last name. Empty names are left
* null in the array.
*
* @param blob compacted class names separated by '|' delimiters
* @return expanded class names
*/
public static String[] splitClassNames(String blob) {
if (blob == null || blob.length() == 0) {
return Utility.EMPTY_STRING_ARRAY;
} else {
GrowableStringArray names = new GrowableStringArray();
String last = "";
int split = -1;
int index = 0;
StringBuffer buff = new StringBuffer();
while (split < blob.length()) {
int base = split + 1;
split = blob.indexOf('|', base);
if (split < 0) {
split = blob.length();
}
if (split > base) {
int mark = 0;
while (base < split) {
char chr = blob.charAt(base);
if (chr == '.') {
mark = last.indexOf('.', mark) + 1;
} else if (chr == '$') {
mark = last.indexOf('$', mark) + 1;
} else {
break;
}
base++;
}
buff.setLength(0);
if (base == split) {
if (mark < last.length()) {
while (++mark < last.length()) {
char chr = last.charAt(mark);
if (chr == '.' || chr == '$') {
break;
}
}
}
buff.append(last.substring(0, mark));
} else {
if (mark > 0) {
buff.append(last.substring(0, mark));
}
buff.append(blob.substring(base, split));
}
last = buff.toString().intern();
names.add(last);
} else {
names.add(null);
}
index++;
}
return names.toArray();
}
}
/**
* Expand names URI indexes into an array of individual names URIs. This is
* used by the generated binding factory code, to reduce the size of the
* generated classes and methods. It takes as input a string where each
* character is a namespace index, biased by +2 in order to avoid the use of
* null characters, along with a table of corresponding namespace URIs. The
* character value 1 is used as a marker for the case where no namespace is
* associated with an index.
*
* @param blob string of characters representing namespace indexes
* @param uris namespace URIs defined in binding
* @return expanded class names
*/
public static String[] expandNamespaces(String blob, String[] uris) {
if (blob == null || blob.length() == 0) {
return Utility.EMPTY_STRING_ARRAY;
} else {
String[] nameuris = new String[blob.length()];
for (int i = 0; i < blob.length(); i++) {
int index = blob.charAt(i) - 2;
if (index >= 0) {
nameuris[i] = uris[index];
}
}
return nameuris;
}
}
/**
* Split concatenated names string into an array of individual names. This
* is used by the binding factory initialization, so that arrays of name
* strings can be represented efficiently in the generated code. It takes
* as input a string consisting of names separated by '|' delimiter
* characters.
*
* @param blob element names separated by '|' delimiters
* @return expanded class names
*/
public static String[] splitNames(String blob) {
if (blob == null || blob.length() == 0) {
return Utility.EMPTY_STRING_ARRAY;
} else {
GrowableStringArray names = new GrowableStringArray();
int split = -1;
int index = 0;
while (split < blob.length()) {
int base = split + 1;
split = blob.indexOf('|', base);
if (split < 0) {
split = blob.length();
}
if (split > base) {
names.add(blob.substring(base, split));
} else {
names.add(null);
}
index++;
}
return names.toArray();
}
}
/**
* Split concatenated ints string into an array of individual int values.
* This is used by the binding factory initialization, so that arrays of
* ints can be represented efficiently in the generated code.
*
* @param blob
* @return expanded index array
*/
public static int[] splitInts(String blob) {
int[] indexes = new int[blob.length()];
for (int i = 0; i < indexes.length; i++) {
indexes[i] = blob.charAt(i) - 1;
}
return indexes;
}
/**
* Parser factory class loader method. This is used during initialization to
* check that a particular factory class is usable.
*
* @param cname class name
* @return reader factory instance
* @throws RuntimeException on error creating class instance
*/
public static IXMLReaderFactory createReaderFactory(String cname) {
// try loading factory class from context loader
Class clas = null;
ClassLoader loader = Thread.currentThread().getContextClassLoader();
if (loader != null) {
try {
clas = loader.loadClass(cname);
} catch (ClassNotFoundException e) { /* deliberately empty */ }
}
if (clas == null) {
// next try the class loader that loaded the unmarshaller interface
try {
loader = IUnmarshallingContext.class.getClassLoader();
clas = loader.loadClass(cname);
} catch (ClassNotFoundException e) {
throw new RuntimeException
("Unable to specified parser factory class " + cname);
}
}
if (! (IXMLReaderFactory.class.isAssignableFrom(clas))) {
throw new RuntimeException("Specified parser factory class " +
cname + " does not implement IXMLReaderFactory interface");
}
// use static method to create parser factory class instance
try {
Method meth = clas.getMethod("getInstance", (Class[])null);
return (IXMLReaderFactory)meth.invoke(null, (Object[])null);
} catch (NoSuchMethodException e) {
throw new RuntimeException("Specified parser factory class " +
cname + " does not define static getInstance() method");
} catch (IllegalAccessException e) {
throw new RuntimeException("Error on parser factory class " +
cname + " getInstance() method call: " + e.getMessage());
} catch (InvocationTargetException e) {
throw new RuntimeException("Error on parser factory class " +
cname + " getInstance() method call: " + e.getMessage());
}
}
/**
* Load the appropriate reader factory. This checks for a system property
* specifying the factory to be used, and if not found checks for an
* instance of one of the standard default factories.
*
* @return factory instance
*/
public static IXMLReaderFactory loadFactory() {
String prop = null;
try {
prop = System.getProperty("org.jibx.runtime.impl.parser");
} catch (SecurityException e) {
/* exception just means the value will be null */
}
if (prop == null) {
// try XMLPull parser factory first
IXMLReaderFactory fact = null;
try {
fact = RuntimeSupport.createReaderFactory
("org.jibx.runtime.impl.XMLPullReaderFactory");
} catch (Throwable e) {
try {
fact = RuntimeSupport.createReaderFactory
("org.jibx.runtime.impl.StAXReaderFactory");
} catch (Throwable e1) {
throw new RuntimeException("Unable to load either XMLPull or StAX parser - check classpath for interface and implementation jars\nXMLPull error " +
e.getClass().getName() + ": " + e.getMessage() + "\nStAX error " + e1.getClass().getName() +
": " + e1.getMessage());
}
}
return fact;
} else {
// try loading factory class specified by property
return RuntimeSupport.createReaderFactory(prop);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/GrowableIntArray.java 0000644 0001750 0001750 00000021046 11160702736 026360 0 ustar twerner twerner /*
Copyright (c) 2000-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.lang.reflect.Array;
/**
* Growable int array with type specific access methods. This
* implementation is unsynchronized in order to provide the best possible
* performance for typical usage scenarios, so explicit synchronization must
* be implemented by a wrapper class or directly by the application in cases
* where instances are modified in a multithreaded environment.
*
* @author Dennis M. Sosnoski
*/
public class GrowableIntArray
{
/** Default initial array size. */
public static final int DEFAULT_SIZE = 8;
/** Size of the current array. */
private int m_countLimit;
/** The number of values currently present in the array. */
private int m_countPresent;
/** Maximum size increment for growing array. */
private int m_maximumGrowth;
/** The underlying array used for storing the data. */
private int[] m_baseArray;
/**
* Constructor with full specification.
*
* @param size number of int values initially allowed in
* array
* @param growth maximum size increment for growing array
*/
public GrowableIntArray(int size, int growth) {
int[] array = new int[size];
m_countLimit = size;
m_maximumGrowth = growth;
m_baseArray = array;
}
/**
* Constructor with initial size specified.
*
* @param size number of int values initially allowed in
* array
*/
public GrowableIntArray(int size) {
this(size, Integer.MAX_VALUE);
}
/**
* Default constructor.
*/
public GrowableIntArray() {
this(DEFAULT_SIZE);
}
/**
* Copy (clone) constructor.
*
* @param base instance being copied
*/
public GrowableIntArray(GrowableIntArray base) {
this(base.m_countLimit, base.m_maximumGrowth);
System.arraycopy(base.m_baseArray, 0, m_baseArray, 0,
base.m_countPresent);
m_countPresent = base.m_countPresent;
}
/**
* Copy data after array resize. This just copies the entire contents of the
* old array to the start of the new array. It should be overridden in cases
* where data needs to be rearranged in the array after a resize.
*
* @param base original array containing data
* @param grown resized array for data
*/
private void resizeCopy(Object base, Object grown) {
System.arraycopy(base, 0, grown, 0, Array.getLength(base));
}
/**
* Increase the size of the array to at least a specified size. The array
* will normally be at least doubled in size, but if a maximum size
* increment was specified in the constructor and the value is less than
* the current size of the array, the maximum increment will be used
* instead. If the requested size requires more than the default growth,
* the requested size overrides the normal growth and determines the size
* of the replacement array.
*
* @param required new minimum size required
*/
private void growArray(int required) {
int size = Math.max(required,
m_countLimit + Math.min(m_countLimit, m_maximumGrowth));
int[] grown = new int[size];
resizeCopy(m_baseArray, grown);
m_countLimit = size;
m_baseArray = grown;
}
/**
* Ensure that the array has the capacity for at least the specified
* number of values.
*
* @param min minimum capacity to be guaranteed
*/
public final void ensureCapacity(int min) {
if (min > m_countLimit) {
growArray(min);
}
}
/**
* Overwrite an existing value in the array.
*
* @param index position of value to be overwritten
* @param value value to be added
*/
public void set(int index, int value) {
if (index < m_countPresent) {
m_baseArray[index] = value;
} else {
throw new IllegalArgumentException("Index value out of range");
}
}
/**
* Add a value at the end of the array.
*
* @param value value to be added
*/
public void add(int value) {
int index = getAddIndex();
m_baseArray[index] = value;
}
/**
* Add an array of values at the end of the array.
*
* @param values values to be added
*/
public void addAll(int[] values) {
ensureCapacity(m_countPresent+values.length);
for (int i = 0; i < values.length; i++) {
m_baseArray[m_countPresent++] = values[i];
}
}
/**
* Remove some number of values from the end of the array.
*
* @param count number of values to be removed
* @exception ArrayIndexOutOfBoundsException on attempt to remove more than
* the count present
*/
public void remove(int count) {
int start = m_countPresent - count;
if (start >= 0) {
m_countPresent = start;
} else {
throw new ArrayIndexOutOfBoundsException
("Attempt to remove too many values from array");
}
}
/**
* Get a value from the array.
*
* @param index index of value to be returned
* @return value from stack
* @exception ArrayIndexOutOfBoundsException on attempt to access outside
* valid range
*/
public int get(int index) {
if (m_countPresent > index) {
return m_baseArray[index];
} else {
throw new ArrayIndexOutOfBoundsException
("Attempt to access past end of array");
}
}
/**
* Constructs and returns a simple array containing the same data as held
* in this array.
*
* @return array containing a copy of the data
*/
public int[] toArray() {
int[] copy = new int[m_countPresent];
System.arraycopy(m_baseArray, 0, copy, 0, m_countPresent);
return copy;
}
/**
* Duplicates the object with the generic call.
*
* @return a copy of the object
*/
public Object clone() {
return new GrowableIntArray(this);
}
/**
* Gets the array offset for appending a value to those in the array. If the
* underlying array is full, it is grown by the appropriate size increment
* so that the index value returned is always valid for the array in use by
* the time of the return.
*
* @return index position for added element
*/
private int getAddIndex() {
int index = m_countPresent++;
if (m_countPresent > m_countLimit) {
growArray(m_countPresent);
}
return index;
}
/**
* Get the number of values currently present in the array.
*
* @return count of values present
*/
public int size() {
return m_countPresent;
}
/**
* Check if array is empty.
*
* @return true if array empty, false if not
*/
public boolean isEmpty() {
return m_countPresent == 0;
}
/**
* Set the array to the empty state.
*/
public void clear() {
m_countPresent = 0;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/MarshallingContext.java 0000644 0001750 0001750 00000135261 11065007470 026754 0 ustar twerner twerner /*
Copyright (c) 2002-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Vector;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.ICharacterEscaper;
import org.jibx.runtime.IExtensibleWriter;
import org.jibx.runtime.IMarshallable;
import org.jibx.runtime.IMarshaller;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IXMLWriter;
import org.jibx.runtime.JiBXException;
/**
* JiBX serializer supplying convenience methods for marshalling. Most of these
* methods are designed for use in code generated by the binding generator.
*
* @author Dennis M. Sosnoski
*/
public class MarshallingContext implements IMarshallingContext
{
/** Fixed XML namespace. */
public static final String XML_NAMESPACE =
"http://www.w3.org/XML/1998/namespace";
/** Starting size for object stack. */
private static final int INITIAL_STACK_SIZE = 20;
/** Binding factory used to create this unmarshaller. */
private IBindingFactory m_factory;
/** Map from fully-qualified class name to index in internal tables. */
private StringIntHashMap m_classIndexMap;
/** Names of classes included in mapping definition. */
private String[] m_classes;
/** Index past end of last fixed marshaller class. */
private int m_transientBase;
/** Transient marshaller classes for mapping definition (null
for mappings out of context). */
private String[] m_transientMarshallerClasses;
/** Marshallers for classes in mapping definition (lazy create of actual
marshaller instances) */
private IMarshaller[] m_marshallers;
/** URIs for namespaces used in binding. */
private String[] m_uris;
/** Current marshalling stack depth. */
private int m_stackDepth;
/** Stack of objects being marshalled. */
private Object[] m_objectStack;
/** Indent character count per level. */
private int m_indentCount;
/** Character sequence for end of line. */
private String m_newLine;
/** Character used for indenting. */
private char m_indentChar;
/** Shared map from IDs to objects. This is not used directly by the
marshalling code, but is available for user extensions (lazy create). */
private HashMap m_idMap;
/** Output document handler. */
private IXMLWriter m_writer;
/** Buffer used when writing to stream (lazy create, null if
unused). */
private OutByteBuffer m_byteBuffer;
/** User context object (not used by JiBX, only for user convenience). */
protected Object m_userContext;
/**
* Constructor.
*
* @param classes ordered array of class names included in mapping
* definition (reference kept, must be constant)
* @param mcs names of marshaller classes for indexes with fixed marshallers
* (as opposed to mapping slots, which may be overridden; reference kept,
* must be constant)
* @param uris ordered array of URIs for namespaces used in binding (must
* be constant; the value in position 0 must always be the empty string "",
* and the value in position 1 must always be the XML namespace
* "http://www.w3.org/XML/1998/namespace")
* @param ifact binding factory creating this unmarshaller
*/
public MarshallingContext(String[] classes, String[] mcs, String[] uris,
IBindingFactory ifact) {
m_classes = classes;
m_marshallers = new IMarshaller[classes.length];
m_transientBase = classes.length - mcs.length;
m_transientMarshallerClasses = new String[classes.length-m_transientBase];
m_uris = uris;
m_objectStack = new Object[INITIAL_STACK_SIZE];
m_indentCount = -1;
m_indentChar = ' ';
m_newLine = "\n";
m_factory = ifact;
if (ifact != null) {
m_classIndexMap = ifact.getClassIndexMap();
} else {
m_classIndexMap = new StringIntHashMap();
}
}
/**
* Create character escaper for encoding.
*
* @param enc document output encoding, or null for default
* @return character escaper for encoding
* @throws JiBXException if error creating setting output
*/
private ICharacterEscaper createEscaper(String enc) throws JiBXException {
if (enc.equalsIgnoreCase("UTF-8") || enc.equalsIgnoreCase("UTF-16") ||
enc.equalsIgnoreCase("UTF-16BE") ||
enc.equalsIgnoreCase("UTF-16LE")) {
return UTF8Escaper.getInstance();
} else if (enc.equalsIgnoreCase("ISO-8859-1")) {
return ISO88591Escaper.getInstance();
} else if (enc.equalsIgnoreCase("US-ASCII")) {
return USASCIIEscaper.getInstance();
} else {
throw new JiBXException
("No character escaper defined for encoding " + enc);
}
}
/**
* Set output stream with encoding and escaper. This forces handling of the
* output stream to use the Java character encoding support with the
* supplied escaper.
*
* @param outs stream for document data output
* @param enc document output encoding, or null uses UTF-8
* default
* @param esc escaper for writing characters to stream
* @throws JiBXException if error setting output
*/
public void setOutput(OutputStream outs, String enc, ICharacterEscaper esc)
throws JiBXException {
try {
// set UTF-8 encoding if not specified
if (enc == null) {
enc = "UTF-8";
}
// make sure the writer can work with an escaper
if (!(m_writer instanceof GenericXMLWriter)) {
m_writer = new GenericXMLWriter(m_uris);
m_writer.setIndentSpaces(m_indentCount, m_newLine,
m_indentChar);
}
// handle encoding using standard libraries
Writer writer = new BufferedWriter
(new OutputStreamWriter(outs, enc));
((GenericXMLWriter)m_writer).setOutput(writer, esc);
reset();
} catch (IOException ex) {
throw new JiBXException("Error setting output", ex);
}
}
/**
* Set output stream and encoding. This uses the standard escaper for the
* specified encoding.
*
* @param outs stream for document data output
* @param enc document output encoding, or null for default
* @throws JiBXException if error creating setting output
*/
public void setOutput(OutputStream outs, String enc) throws JiBXException {
// set UTF-8 encoding if not specified
if (enc == null) {
enc = "UTF-8";
}
if ("UTF-8".equalsIgnoreCase(enc)) {
// handle UTF-8 output to stream directly
if (!(m_writer instanceof UTF8StreamWriter)) {
if (m_byteBuffer == null) {
m_byteBuffer = new OutByteBuffer();
}
UTF8StreamWriter wrtr = new UTF8StreamWriter(m_uris);
m_writer = wrtr;
wrtr.setBuffer(m_byteBuffer);
wrtr.setIndentSpaces(m_indentCount, m_newLine,
m_indentChar);
}
reset();
m_byteBuffer.setOutput(outs);
} else if ("ISO-8859-1".equalsIgnoreCase(enc)) {
// handle ISO-8859-1 output to stream directly
if (!(m_writer instanceof ISO88591StreamWriter)) {
if (m_byteBuffer == null) {
m_byteBuffer = new OutByteBuffer();
}
ISO88591StreamWriter wrtr = new ISO88591StreamWriter(m_uris);
m_writer = wrtr;
wrtr.setBuffer(m_byteBuffer);
wrtr.setIndentSpaces(m_indentCount, m_newLine,
m_indentChar);
}
reset();
m_byteBuffer.setOutput(outs);
} else {
setOutput(outs, enc, createEscaper(enc));
}
}
/**
* Set output writer and escaper.
*
* @param outw writer for document data output
* @param esc escaper for writing characters
*/
public void setOutput(Writer outw, ICharacterEscaper esc) {
if (!(m_writer instanceof GenericXMLWriter)) {
m_writer = new GenericXMLWriter(m_uris);
m_writer.setIndentSpaces(m_indentCount, m_newLine,
m_indentChar);
}
((GenericXMLWriter)m_writer).setOutput(outw, esc);
reset();
}
/**
* Set output writer.
*
* @param outw writer for document data output
*/
public void setOutput(Writer outw) {
setOutput(outw, UTF8Escaper.getInstance());
}
/**
* Get the writer being used for output.
*
* @return XML writer used for output
*/
public IXMLWriter getXmlWriter() {
return m_writer;
}
/**
* Set the writer being used for output.
*
* @param xwrite XML writer used for output
*/
public void setXmlWriter(IXMLWriter xwrite) {
m_writer = xwrite;
}
/**
* Get current nesting indent spaces. This returns the number of spaces used
* to show indenting, if used.
*
* @return number of spaces indented per level, or negative if indentation
* disabled
*/
public int getIndent() {
return m_indentCount;
}
/**
* Set nesting indent spaces. This is advisory only, and implementations of
* this interface are free to ignore it. The intent is to indicate that the
* generated output should use indenting to illustrate element nesting.
*
* @param count number of spaces to indent per level, or disable
* indentation if negative
*/
public void setIndent(int count) {
if (m_writer != null) {
m_writer.setIndentSpaces(count, m_newLine, m_indentChar);
}
m_indentCount = count;
}
/**
* Set nesting indentation. This is advisory only, and implementations of
* this interface are free to ignore it. The intent is to indicate that the
* generated output should use indenting to illustrate element nesting.
*
* @param count number of character to indent per level, or disable
* indentation if negative (zero means new line only)
* @param newline sequence of characters used for a line ending
* (null means use the single character '\n')
* @param indent whitespace character used for indentation
*/
public void setIndent(int count, String newline, char indent) {
if (m_writer != null) {
m_writer.setIndentSpaces(count, newline, indent);
}
m_indentCount = count;
m_newLine = newline;
m_indentChar = indent;
}
/**
* Initializes the context to use the same marshalled text destination and
* parameters as another marshalling context. This method is designed for
* use when an initial context needs to create and invoke a secondary
* context (generally from a different binding) in the course of an
* marshalling operation. Note that once the secondary context has been used
* it's generally necessary to do a {@link XMLWriterBase#flush()} operation
* on the writer used by the that context before resuming output on the
* parent.
*
* @param parent context supplying target for marshalled document text
* @throws IOException on error writing output
*/
public void setFromContext(MarshallingContext parent) throws IOException {
reset();
m_indentCount = parent.m_indentCount;
m_newLine = parent.m_newLine;
m_indentChar = parent.m_indentChar;
if (parent.m_writer instanceof IExtensibleWriter) {
IExtensibleWriter base = (IExtensibleWriter)parent.m_writer;
base.flush();
m_writer = base.createChildWriter(m_uris);
} else if (parent.m_writer instanceof StAXWriter) {
m_writer = ((StAXWriter)parent.m_writer).createChildWriter(m_uris);
} else {
m_writer = parent.m_writer;
}
}
/**
* Reset to initial state for reuse. The context is serially reusable,
* as long as this method is called to clear any retained state information
* between uses. It is automatically called when output is set.
*/
public void reset() {
if (m_writer != null) {
m_writer.reset();
}
for (int i = 0; i < m_marshallers.length; i++) {
m_marshallers[i] = null;
}
for (int i = 0; i < m_transientMarshallerClasses.length; i++) {
m_transientMarshallerClasses[i] = null;
}
for (int i = 0; i < m_objectStack.length; i++) {
m_objectStack[i] = null;
}
m_stackDepth = 0;
}
/**
* Return the binding factory used to create this unmarshaller.
*
* @return binding factory
*/
public IBindingFactory getFactory() {
return m_factory;
}
/**
* Get namespace URIs for mapping. This gets the full ordered array of
* namespaces known in the binding used for this marshalling, where the
* index number of each namespace URI is the namespace index used to lookup
* the prefix when marshalling a name in that namespace. The returned array
* must not be modified.
*
* @return array of namespaces
*/
public String[] getNamespaces() {
return m_uris;
}
/**
* Start document. This can only be validly called immediately following
* one of the set output methods; otherwise the output document will be
* corrupt.
*
* @param enc document encoding, null if not specified
* @param alone standalone document flag, null if not
* specified
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public void startDocument(String enc, Boolean alone) throws JiBXException {
try {
String atext = null;
if (alone != null) {
atext = alone.booleanValue() ? "yes" : "no";
}
m_writer.writeXMLDecl("1.0", enc, atext);
} catch (IOException ex) {
throw new JiBXException("Error writing marshalled document", ex);
}
}
/**
* Start document with output stream and encoding. The effect is the same
* as from first setting the output stream and encoding, then making the
* call to start document.
*
* @param enc document encoding, null if not specified
* @param alone standalone document flag, null if not
* specified
* @param outs stream for document data output
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public void startDocument(String enc, Boolean alone, OutputStream outs)
throws JiBXException {
setOutput(outs, enc);
startDocument(enc, alone);
}
/**
* Start document with writer. The effect is the same as from first
* setting the writer, then making the call to start document.
*
* @param enc document encoding, null if not specified
* @param alone standalone document flag, null if not
* specified
* @param outw writer for document data output
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public void startDocument(String enc, Boolean alone, Writer outw)
throws JiBXException {
setOutput(outw);
startDocument(enc, alone);
}
/**
* End document. Finishes all output and closes the document. Note that if
* this is called with an imcomplete marshalling the result will not be
* well-formed XML.
*
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public void endDocument() throws JiBXException {
try {
m_writer.close();
} catch (IOException ex) {
throw new JiBXException("Error writing marshalled document", ex);
}
}
/**
* Build name with optional namespace. Just returns the appropriate
* name format.
*
* @param index namespace URI index number
* @param name local name part of name
* @return formatted name string
*/
public String buildNameString(int index, String name) {
String ns = m_writer.getNamespaceUri(index);
if (ns == null || "".equals(ns)) {
return "\"" + name + "\"";
} else {
return "\"{" + ns + "}" + name + "\"";
}
}
/**
* Generate start tag for element without attributes.
*
* @param index namespace URI index number
* @param name element name
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext startTag(int index, String name)
throws JiBXException {
try {
m_writer.startTagClosed(index, name);
return this;
} catch (IOException ex) {
throw new JiBXException("Error writing marshalled document", ex);
}
}
/**
* Generate start tag for element with attributes. This only opens the start
* tag, allowing attributes to be added immediately following this call.
*
* @param index namespace URI index number
* @param name element name
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext startTagAttributes(int index, String name)
throws JiBXException {
try {
m_writer.startTagOpen(index, name);
return this;
} catch (IOException ex) {
throw new JiBXException("Error writing marshalled document", ex);
}
}
/**
* Generate text attribute. This can only be used following an open start
* tag with attributes.
*
* @param index namespace URI index number
* @param name attribute name
* @param value text value for attribute (cannot be null)
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext attribute(int index, String name, String value)
throws JiBXException {
try {
m_writer.addAttribute(index, name, value);
return this;
} catch (IOException ex) {
throw new JiBXException("Error writing marshalled document", ex);
} catch (Exception ex) {
String text = buildNameString(index, name);
if (value == null) {
throw new JiBXException("null value for attribute " +
text + " from object of type " +
getStackTop().getClass().getName());
} else {
throw new JiBXException
("Exception while marshalling attribute " + text, ex);
}
}
}
/**
* Generate integer attribute. This can only be used following an open start
* tag.
*
* @param index namespace URI index number
* @param name attribute name
* @param value integer value for attribute
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext attribute(int index, String name, int value)
throws JiBXException {
return attribute(index, name, Integer.toString(value));
}
/**
* Generate enumeration attribute. The actual text to be written is obtained
* by indexing into the supplied array of values. This can only be used
* following an open start tag.
*
* @param index namespace URI index number
* @param name attribute name
* @param value integer enumeration value (zero-based)
* @param table text values in enumeration
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext attribute(int index, String name, int value,
String[] table) throws JiBXException {
try {
return attribute(index, name, table[value]);
} catch (ArrayIndexOutOfBoundsException ex) {
throw new JiBXException("Enumeration value of " + value +
" is outside to allowed range of 0 to " + table.length);
}
}
/**
* Close start tag with content to follow.
*
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext closeStartContent() throws JiBXException {
try {
m_writer.closeStartTag();
return this;
} catch (IOException ex) {
throw new JiBXException("Error writing marshalled document", ex);
}
}
/**
* Close start tag with no content (empty tag).
*
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext closeStartEmpty() throws JiBXException {
try {
m_writer.closeEmptyTag();
return this;
} catch (IOException ex) {
throw new JiBXException("Error writing marshalled document", ex);
}
}
/**
* Add text content to current element.
*
* @param value text element content
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext content(String value) throws JiBXException {
try {
m_writer.writeTextContent(value);
return this;
} catch (IOException ex) {
throw new JiBXException("Error writing marshalled document", ex);
}
}
/**
* Add integer content to current element.
*
* @param value integer element content
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext content(int value) throws JiBXException {
content(Integer.toString(value));
return this;
}
/**
* Add enumeration content to current element. The actual text to be
* written is obtained by indexing into the supplied array of values.
*
* @param value integer enumeration value (zero-based)
* @param table text values in enumeration
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext content(int value, String[] table)
throws JiBXException {
try {
content(table[value]);
return this;
} catch (ArrayIndexOutOfBoundsException ex) {
throw new JiBXException("Enumeration value of " + value +
" is outside to allowed range of 0 to " + table.length);
}
}
/**
* Generate end tag for element.
*
* @param index namespace URI index number
* @param name element name
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext endTag(int index, String name)
throws JiBXException {
try {
m_writer.endTag(index, name);
return this;
} catch (IOException ex) {
throw new JiBXException("Error writing marshalled document", ex);
}
}
/**
* Generate complete element with text content.
*
* @param index namespace URI index number
* @param name element name
* @param value text element content
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext element(int index, String name, String value)
throws JiBXException {
try {
if (value.length() == 0) {
m_writer.startTagOpen(index, name);
m_writer.closeEmptyTag();
} else {
m_writer.startTagClosed(index, name);
m_writer.writeTextContent(value);
m_writer.endTag(index, name);
}
return this;
} catch (IOException ex) {
throw new JiBXException("Error writing marshalled document", ex);
} catch (Exception ex) {
String text = buildNameString(index, name);
if (value == null) {
throw new JiBXException("null value for element " +
text + " from object of type " +
getStackTop().getClass().getName());
} else {
throw new JiBXException
("Exception while marshalling element " + text, ex);
}
}
}
/**
* Generate complete element with integer content.
*
* @param index namespace URI index number
* @param name element name
* @param value integer element content
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext element(int index, String name, int value)
throws JiBXException {
return element(index, name, Integer.toString(value));
}
/**
* Generate complete element with enumeration content. The actual text to be
* written is obtained by indexing into the supplied array of values.
*
* @param index namespace URI index number
* @param name element name
* @param value integer enumeration value (zero-based)
* @param table text values in enumeration
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext element(int index, String name, int value,
String[] table) throws JiBXException {
try {
return element(index, name, table[value]);
} catch (ArrayIndexOutOfBoundsException ex) {
throw new JiBXException("Enumeration value of " + value +
" is outside to allowed range of 0 to " + table.length);
}
}
/**
* Write CDATA text to document.
*
* @param text content value text
* @return this context (to allow chained calls)
* @throws IOException on error writing to document
*/
public MarshallingContext writeCData(String text) throws IOException {
try {
m_writer.writeCData(text);
return this;
} catch (NullPointerException e) {
if (text == null) {
throw new IOException
("Null value writing CDATA from object of type " +
getStackTop().getClass().getName());
} else {
throw e;
}
}
}
/**
* Write content value with character entity substitutions.
*
* @param text content value text
* @return this context (to allow chained calls)
* @throws IOException on error writing to document
*/
public MarshallingContext writeContent(String text) throws IOException {
try {
m_writer.writeTextContent(text);
return this;
} catch (NullPointerException e) {
if (text == null) {
throw new IOException
("Null value writing text content from object " +
getStackTop().getClass().getName());
} else {
throw e;
}
}
}
/**
* Marshal all items in a collection. This variation is for generic
* collections.
*
* @param col collection of items to be marshalled
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext marshalCollection(Collection col)
throws JiBXException {
Iterator iter = col.iterator();
while (iter.hasNext()) {
Object obj = iter.next();
if (obj instanceof IMarshallable) {
((IMarshallable)obj).marshal(this);
} else {
throw new JiBXException
("Unmarshallable object of class " + obj.getClass() +
" found in marshalling");
}
}
return this;
}
/**
* Marshal all items in a collection. This variation is for ArrayList
* collections.
*
* @param col collection of items to be marshalled
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext marshalCollection(ArrayList col)
throws JiBXException {
for (int i = 0; i < col.size(); i++) {
Object obj = col.get(i);
if (obj instanceof IMarshallable) {
((IMarshallable)obj).marshal(this);
} else {
throw new JiBXException
("Unmarshallable object of class " +
obj.getClass().getName() + " found in marshalling");
}
}
return this;
}
/**
* Marshal all items in a collection. This variation is for Vector
* collections.
*
* @param col collection of items to be marshalled
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext marshalCollection(Vector col)
throws JiBXException {
for (int i = 0; i < col.size(); i++) {
Object obj = col.elementAt(i);
if (obj instanceof IMarshallable) {
((IMarshallable)obj).marshal(this);
} else {
throw new JiBXException
("Unmarshallable object of class " +
obj.getClass().getName() + " found in marshalling");
}
}
return this;
}
/**
* Define marshalling for class. Adds the marshalling definition for a
* particular mapping name.
*
* @param mapname mapping name associated with unmarshaller
* @param name marshaller class name handling
* @throws JiBXException if unknown mapping name
*/
public void addMarshalling(String mapname, String name)
throws JiBXException {
int index = m_classIndexMap.get(mapname);
if (index < 0) {
throw new JiBXException("No marshal mapping defined for class " + mapname);
}
m_transientMarshallerClasses[index-m_transientBase] = name;
}
/**
* Undefine marshalling for element. Removes the marshalling
* definition for a particular mapping name.
*
* @param mapname mapping name associated with unmarshaller
* @throws JiBXException if unknown mapping name
*/
public void removeMarshalling(String mapname) throws JiBXException {
int index = m_classIndexMap.get(mapname);
if (index < 0) {
throw new JiBXException("No marshal mapping defined for class " + mapname);
}
m_transientMarshallerClasses[index-m_transientBase] = null;
m_marshallers[index] = null;
}
/**
* Generate start tag for element with namespaces. This creates the actual
* start tag, along with any necessary namespace declarations. Previously
* active namespace declarations are not duplicated. The tag is
* left incomplete, allowing other attributes to be added.
*
* TODO: Handle nested default namespaces declarations, prefixes for outers
*
* @param index namespace URI index number
* @param name element name
* @param nums array of namespace indexes defined by this element (must
* be constant, reference is kept until end of element)
* @param prefs array of namespace prefixes mapped by this element (no
* null values, use "" for default namespace declaration)
* @return this context (to allow chained calls)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public MarshallingContext startTagNamespaces(int index, String name,
int[] nums, String[] prefs) throws JiBXException {
try {
m_writer.startTagNamespaces(index, name, nums, prefs);
return this;
} catch (IOException ex) {
throw new JiBXException("Error writing marshalled document", ex);
}
}
/**
* Find the marshaller for a particular class index in the current context.
*
* @param mapname marshaller mapping name (generally the class name to be
* handled, or abstract mapping type name)
* @return marshalling handler for class
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public IMarshaller getMarshaller(String mapname) throws JiBXException {
int index = m_classIndexMap.get(mapname);
if (index < 0) {
throw new JiBXException("No marshal mapping defined for class " + mapname);
}
if (m_marshallers[index] == null) {
// load the marshaller class and create an instance
Class clas;
String mname = m_factory.getMarshallerClasses()[index];
if (mname != null) {
// get global marshaller class through factory
clas = m_factory.getMarshallerClass(index);
} else {
// load transient marshaller class directly
mname = m_transientMarshallerClasses[index-m_transientBase];
if (mname == null) {
throw new JiBXException("No marshaller defined for class " + mapname);
}
clas = m_factory.loadClass(mname);
}
try {
// make sure we have a class
if (clas == null) {
throw new JiBXException("Unable to load marshaller class " + mname);
}
// create and cache an instance of the class
IMarshaller m = (IMarshaller)clas.newInstance();
m_marshallers[index] = m;
} catch (JiBXException e) {
throw e;
} catch (Exception e) {
throw new JiBXException("Unable to create marshaller of class " + mname + ":", e);
}
}
return m_marshallers[index];
}
/**
* Marshal document from root object. This internal method just verifies
* that the object is marshallable, then calls the marshal method on the
* object itself.
*
* @param root object at root of structure to be marshalled, which must have
* a top-level mapping in the binding
* @throws JiBXException on any error (possibly wrapping other exception)
*/
protected void marshalRoot(Object root) throws JiBXException {
if (root instanceof IMarshallable) {
((IMarshallable)root).marshal(this);
} else {
throw new JiBXException("Supplied root object of class " +
root.getClass().getName() +
" cannot be marshalled without top-level mapping");
}
}
/**
* Marshal document from root object without XML declaration. This can only
* be validly called immediately following one of the set output methods;
* otherwise the output document will be corrupt. The effect of this method
* is the same as the sequence of a call to marshal the root object using
* this context followed by a call to {@link #endDocument}.
*
* @param root object at root of structure to be marshalled, which must have
* a top-level mapping in the binding
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public void marshalDocument(Object root) throws JiBXException {
marshalRoot(root);
endDocument();
}
/**
* Marshal document from root object. This can only be validly called
* immediately following one of the set output methods; otherwise the output
* document will be corrupt. The effect of this method is the same as the
* sequence of a call to {@link #startDocument}, a call to marshal the root
* object using this context, and finally a call to {@link #endDocument}.
*
* @param root object at root of structure to be marshalled, which must have
* a top-level mapping in the binding
* @param enc document encoding, null if not specified
* @param alone standalone document flag, null if not
* specified
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public void marshalDocument(Object root, String enc, Boolean alone)
throws JiBXException {
startDocument(enc, alone);
marshalRoot(root);
endDocument();
}
/**
* Marshal document from root object to output stream with encoding. The
* effect of this method is the same as the sequence of a call to {@link
* #startDocument}, a call to marshal the root object using this context,
* and finally a call to {@link #endDocument}.
*
* @param root object at root of structure to be marshalled, which must have
* a top-level mapping in the binding
* @param enc document encoding, null if not specified
* @param alone standalone document flag, null if not
* specified
* @param outs stream for document data output
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public void marshalDocument(Object root, String enc, Boolean alone,
OutputStream outs) throws JiBXException {
startDocument(enc, alone, outs);
marshalRoot(root);
endDocument();
}
/**
* Marshal document from root object to writer. The effect of this method
* is the same as the sequence of a call to {@link #startDocument}, a call
* to marshal the root object using this context, and finally a call to
* {@link #endDocument}.
*
* @param root object at root of structure to be marshalled, which must have
* a top-level mapping in the binding
* @param enc document encoding, null if not specified
* @param alone standalone document flag, null if not
* specified
* @param outw writer for document data output
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public void marshalDocument(Object root, String enc, Boolean alone,
Writer outw) throws JiBXException {
startDocument(enc, alone, outw);
marshalRoot(root);
endDocument();
}
/**
* Use namespace indexes from a separate binding, as identified by that
* binding's factory class name. The target binding must be a precompiled
* base binding of the binding used to create this marshalling context,
* either directly or by way of some other precompiled base binding(s).
*
* @param factname binding factory class name for binding defining namespaces
*/
public void pushNamespaces(String factname) {
Map tablemap = m_factory.getNamespaceTranslationTableMap();
m_writer.pushTranslationTable((int[])tablemap.get(factname));
}
/**
* End use of namespace indexes from a separate binding. This will undo the
* effect of the most-recent call to {@link #pushNamespaces(String)},
* restoring whatever namespace usage was in effect prior to that call.
*/
public void popNamespaces() {
m_writer.popTranslationTable();
}
/**
* Get shared ID map. The ID map returned is not used directly by the
* marshalling code, but is provided to support user extensions.
*
* @return ID map
*/
public HashMap getIdMap() {
if (m_idMap == null) {
m_idMap = new HashMap();
}
return m_idMap;
}
/**
* Set a user context object. This context object is not used directly by
* JiBX, but can be accessed by all types of user extension methods. The
* context object is automatically cleared by the {@link #reset()} method,
* so to make use of this you need to first call the appropriate version of
* the setOutput() method, then this method, and finally one of
* the marshalDocument methods which uses the previously-set
* output (not the ones which take a stream or writer as parameter, since
* they call setOutput() themselves).
*
* @param obj user context object, or null if clearing existing
* context object
* @see #getUserContext()
*/
public void setUserContext(Object obj) {
m_userContext = obj;
}
/**
* Get the user context object.
*
* @return user context object, or null if no context object
* set
* @see #setUserContext(Object)
*/
public Object getUserContext() {
return m_userContext;
}
/**
* Push created object to marshalling stack. This must be called before
* beginning the marshalling of the object. It is only called for objects
* with structure, not for those converted directly to and from text.
*
* @param obj object being marshalled
*/
public void pushObject(Object obj) {
if (obj == null) {
throw new IllegalStateException("Missing required object");
}
int depth = m_stackDepth;
if (depth >= m_objectStack.length) {
Object[] stack = new Object[depth*2];
System.arraycopy(m_objectStack, 0, stack, 0, depth);
m_objectStack = stack;
}
m_objectStack[depth] = obj;
m_stackDepth++;
}
/**
* Pop marshalled object from stack.
*
* @throws JiBXException if no object on stack
*/
public void popObject() throws JiBXException {
if (m_stackDepth > 0) {
--m_stackDepth;
} else {
throw new JiBXException("No object on stack");
}
}
/**
* Get current marshalling object stack depth. This allows tracking
* nested calls to marshal one object while in the process of
* marshalling another object. The bottom item on the stack is always the
* root object being marshalled.
*
* @return number of objects in marshalling stack
*/
public int getStackDepth() {
return m_stackDepth;
}
/**
* Get object from marshalling stack. This stack allows tracking nested
* calls to marshal one object while in the process of marshalling
* another object. The bottom item on the stack is always the root object
* being marshalled.
*
* @param depth object depth in stack to be retrieved (must be in the range
* of zero to the current depth minus one).
* @return object from marshalling stack
*/
public Object getStackObject(int depth) {
return m_objectStack[m_stackDepth-depth-1];
}
/**
* Get top object on marshalling stack. This is safe to call even when no
* objects are on the stack.
*
* @return object from marshalling stack, or null if none
*/
public Object getStackTop() {
if (m_stackDepth > 0) {
return m_objectStack[m_stackDepth-1];
} else {
return null;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/IByteBuffer.java 0000644 0001750 0001750 00000005743 11065007470 025315 0 ustar twerner twerner /*
Copyright (c) 2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
/**
* Input or output buffer interface. It exposes a byte array buffer directly for
* use by client code, to allow efficient buffering of data without copying.
* This obviously requires client code to be careful to obey the access rules
* stated in the method documentation.
*
* @author Dennis M. Sosnoski
*/
public interface IByteBuffer
{
/**
* Get the byte array buffer.
*
* @return array
*/
byte[] getBuffer();
/**
* Get the current offset. For an input buffer this is the index of the next
* byte to be read, for an output buffer it is the index to store the next
* byte to be written. After reading or writing data, the {@link
* #setOffset(int)} method must be used to update the current offset before
* any other operations are performed on the buffer.
*
* @return offset
*/
int getOffset();
/**
* Set the current offset. This method must be used to update the internal
* buffer state after reading or writing any data.
*
* @param offset
*/
void setOffset(int offset);
/**
* Complete usage of the buffer. This method should be called whenever the
* application is done reading or writing the buffer. After this method is
* called the buffer may need to be reinitialized (such as by setting a new
* input or output stream) before it is reused.
*
* @throws IOException
*/
void finish() throws IOException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/StAXReaderFactory.java 0000644 0001750 0001750 00000014100 10611642106 026421 0 ustar twerner twerner /*
Copyright (c) 2005, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.InputStream;
import java.io.Reader;
import javax.xml.stream.FactoryConfigurationError;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import org.jibx.runtime.IXMLReader;
import org.jibx.runtime.JiBXException;
/**
* Factory for creating XMLPull parser instances.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class StAXReaderFactory implements IXMLReaderFactory
{
/** Singleton instance of class. */
private static final StAXReaderFactory s_instance = new StAXReaderFactory();
/** Factory used for constructing parser instances. */
private final XMLInputFactory m_factory;
/** Namespace processing state configured on factory. */
private boolean m_isNamespaceEnabled;
/**
* Internal constructor.
*/
private StAXReaderFactory() {
XMLInputFactory factory;
try {
factory = XMLInputFactory.newInstance();
} catch (FactoryConfigurationError e) {
Thread thread = Thread.currentThread();
ClassLoader cl = thread.getContextClassLoader();
thread.setContextClassLoader
(StAXReaderFactory.class.getClassLoader());
try {
factory = XMLInputFactory.newInstance();
} finally {
thread.setContextClassLoader(cl);
}
}
m_factory = factory;
m_isNamespaceEnabled = true;
}
/**
* Get instance of factory.
*
* @return factory instance
*/
public static StAXReaderFactory getInstance() {
return s_instance;
}
/**
* Create new parser instance. In order to avoid thread safety issues the
* caller must have a lock on the factory object.
*
* @param nsf enable namespace processing on parser flag
* @throws JiBXException on error creating parser
*/
private void setNamespacesState(boolean nsf) throws JiBXException {
if (nsf != m_isNamespaceEnabled) {
try {
m_factory.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE,
nsf ? Boolean.TRUE : Boolean.FALSE);
m_isNamespaceEnabled = nsf;
} catch (IllegalArgumentException e) {
throw new JiBXException
("Unable to create parser with required namespace handling");
}
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.impl.IXMLReaderFactory#createReader(java.io.InputStream, java.lang.String, java.lang.String, boolean)
*/
public IXMLReader createReader(InputStream is, String name, String enc,
boolean nsf) throws JiBXException {
try {
synchronized (m_factory) {
setNamespacesState(nsf);
if (enc == null) {
XMLStreamReader rdr = m_factory.createXMLStreamReader(is);
return new StAXReaderWrapper(rdr, name, nsf);
} else {
XMLStreamReader rdr =
m_factory.createXMLStreamReader(is, enc);
return new StAXReaderWrapper(rdr, name, nsf);
}
}
} catch (XMLStreamException e) {
throw new JiBXException("Error creating parser", e);
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.impl.IXMLReaderFactory#createReader(java.io.Reader, java.lang.String, boolean)
*/
public IXMLReader createReader(Reader rdr, String name, boolean nsf)
throws JiBXException {
try {
synchronized (m_factory) {
setNamespacesState(nsf);
return new StAXReaderWrapper(m_factory.createXMLStreamReader(rdr),
name, nsf);
}
} catch (XMLStreamException e) {
throw new JiBXException("Error creating parser", e);
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.impl.IXMLReaderFactory#recycleReader(org.jibx.runtime.IXMLReader, java.io.InputStream, java.lang.String, java.lang.String)
*/
public IXMLReader recycleReader(IXMLReader old, InputStream is, String name,
String enc) throws JiBXException {
return createReader(is, name, enc, old.isNamespaceAware());
}
/* (non-Javadoc)
* @see org.jibx.runtime.impl.IXMLReaderFactory#recycleReader(org.jibx.runtime.IXMLReader, java.io.Reader, java.lang.String)
*/
public IXMLReader recycleReader(IXMLReader old, Reader rdr, String name)
throws JiBXException {
return createReader(rdr, name, old.isNamespaceAware());
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/OutByteBuffer.java 0000644 0001750 0001750 00000015323 11066266234 025675 0 ustar twerner twerner /*
Copyright (c) 2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
import java.io.OutputStream;
/**
* Byte buffer wrapping an output stream. Clients need to obey the interface
* access rules.
*
* @author Dennis M. Sosnoski
*/
public class OutByteBuffer implements IOutByteBuffer
{
/** Default output buffer size. */
public static final int DEFAULT_BUFFER_SIZE = 4096;
/** Stream for byte output. */
private OutputStream m_stream;
/** Buffer for output bytes. */
private byte[] m_buffer;
/** Current offset for adding bytes to buffer. */
private int m_offset;
/**
* Constructor with size specified.
*
* @param size initial buffer size in bytes
*/
public OutByteBuffer(int size) {
m_buffer = new byte[size];
}
/**
* Constructor using default buffer size.
*/
public OutByteBuffer() {
this(DEFAULT_BUFFER_SIZE);
}
/**
* Reset to initial state for reuse.
*/
public void reset() {
m_offset = 0;
m_stream = null;
}
/**
* Set output stream. If an output stream is currently open when this is
* called the existing stream is flushed and closed, with any errors
* ignored.
*
* @param os stream
*/
public void setOutput(OutputStream os) {
try {
finish();
} catch (IOException e) { /* deliberately empty */ }
reset();
m_stream = os;
}
//
// IOutByteBuffer implementation
/**
* Get the byte array buffer.
*
* @return array
*/
public byte[] getBuffer() {
return m_buffer;
}
/**
* Get the index of the next byte to be read. After reading data, the {@link
* #setOffset(int)} method must be used to update the current offset before
* any other operations are performed on the buffer.
*
* @return offset
*/
public int getOffset() {
return m_offset;
}
/**
* Set the current offset. This must be used to update the stored buffer
* state after reading any data.
*
* @param offset
*/
public void setOffset(int offset) {
m_offset = offset;
}
/**
* Free at least some number of bytes of space in the byte array. If no
* reserve is specified, this call may write all data up to the current
* offset to the output stream, and if necessary will replace the byte array
* with a larger array. If a reserve is specified, only data up to the
* reserve will be written, and any remaining data will be moved down to the
* start of the (possibly new) byte array on return. Both {@link
* #getBuffer()} and {@link IByteBuffer#getOffset()} must always be called
* again before any further use of the buffer.
*
* @param reserve offset of data to be preserved in buffer (nothing
* preserved if greater than or equal to current offset)
* @param size desired number of bytes
* @throws IOException
*/
public void free(int reserve, int size) throws IOException {
if (m_buffer.length - m_offset < size) {
// check if reserve sets limit on write
if (reserve < m_offset) {
// write what we can, then check for array resize needed
m_stream.write(m_buffer, 0, reserve);
m_offset = m_offset - reserve;
int need = reserve + size;
if (need > m_buffer.length) {
// resize array, copying data between reserve and offset
byte[] newbuf = new byte[Math.max(need, m_buffer.length+2)];
System.arraycopy(m_buffer, reserve, newbuf, 0, m_offset);
m_buffer = newbuf;
} else {
// just copy data in array down to start
System.arraycopy(m_buffer, reserve, m_buffer, 0, m_offset);
}
} else {
// just write all present and replace array if needed
m_stream.write(m_buffer, 0, m_offset);
if (size > m_buffer.length) {
m_buffer = new byte[Math.max(size, m_buffer.length*2)];
}
m_offset = 0;
}
}
}
/**
* Empty the buffer. Writes all data from the buffer to the output stream,
* resetting the offset to the start of the buffer.
*
* @throws IOException
*/
public void flush() throws IOException {
if (m_offset > 0) {
m_stream.write(m_buffer, 0, m_offset);
m_offset = 0;
}
}
/**
* Complete usage of the current stream. This method should be called
* whenever the application is done writing to the buffered stream. Once
* this method is called, a call to {@link #setOutput(OutputStream)} is
* required before the buffer can again be used.
*
* @throws IOException
*/
public void finish() throws IOException {
if (m_stream != null) {
flush();
m_stream.close();
m_stream = null;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/StreamWriterBase.java 0000644 0001750 0001750 00000037324 11357673024 026402 0 ustar twerner twerner /*
Copyright (c) 2004-2010, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
/**
* Base handler for marshalling text document to an output stream. This needs to
* be subclassed with implementation methods specific to the encoding used.
*
* @author Dennis M. Sosnoski
*/
public abstract class StreamWriterBase extends XMLWriterBase
{
//
// Defined entities and special sequences as bytes
protected final byte[] m_quotEntityBytes;
protected final byte[] m_ampEntityBytes;
protected final byte[] m_gtEntityBytes;
protected final byte[] m_ltEntityBytes;
protected final byte[] m_cdataStartBytes;
protected final byte[] m_cdataEndBytes;
/** Output buffer. */
private IOutByteBuffer m_byteBuffer;
/** Name of encoding used for stream. */
private final String m_encodingName;
/** Original writer (only used when created using copy constructor,
null otherwise). */
private final StreamWriterBase m_baseWriter;
/** Cached reference to byte array used by buffer. */
protected byte[] m_buffer;
/** Current fill offset in buffer byte array. */
protected int m_fillOffset;
/** Byte sequences for prefixes of namespaces in scope. */
protected byte[][] m_prefixBytes;
/** Byte sequences for prefixes of extension namespaces in scope. */
protected byte[][][] m_extensionBytes;
/** Indent tags for pretty-printed text. */
private boolean m_indent;
/** Base number of characters in indent sequence (end of line only). */
private int m_indentBase;
/** Number of extra characters in indent sequence per level of nesting. */
private int m_indentPerLevel;
/** Raw text for indentation sequences. */
private byte[] m_indentSequence;
/**
* Constructor with supplied buffer.
*
* @param enc character encoding used for output to streams (upper case)
* @param uris ordered array of URIs for namespaces used in document (must
* be constant; the value in position 0 must always be the empty string "",
* and the value in position 1 must always be the XML namespace
* "http://www.w3.org/XML/1998/namespace")
*/
protected StreamWriterBase(String enc, String[] uris) {
super(uris);
m_encodingName = enc;
m_baseWriter = null;
m_prefixBytes = new byte[uris.length][];
try {
m_quotEntityBytes = """.getBytes(m_encodingName);
m_ampEntityBytes = "&".getBytes(m_encodingName);
m_gtEntityBytes = ">".getBytes(m_encodingName);
m_ltEntityBytes = "<".getBytes(m_encodingName);
m_cdataStartBytes = "".getBytes(m_encodingName);
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException
("Internal error - unsupported encoding " + m_encodingName);
}
}
/**
* Copy constructor. This takes the stream and encoding information from a
* supplied instance, while setting a new array of namespace URIs. It's
* intended for use when invoking one binding from within another binding.
*
* @param base instance to be used as base for writer
* @param uris ordered array of URIs for namespaces used in document
* (see {@link #StreamWriterBase(String, String[])})
*/
public StreamWriterBase(StreamWriterBase base, String[] uris) {
super(base, uris);
m_encodingName = base.m_encodingName;
m_baseWriter = base;
m_prefixBytes = new byte[uris.length][];
m_byteBuffer = base.m_byteBuffer;
m_buffer = base.m_buffer;
m_fillOffset = base.m_fillOffset;
m_indent = base.m_indent;
m_indentBase = base.m_indentBase;
m_indentPerLevel = base.m_indentPerLevel;
m_indentSequence = base.m_indentSequence;
byte[][][] extbytes = base.m_extensionBytes;
if (extbytes != null) {
m_extensionBytes = new byte[extbytes.length][][];
System.arraycopy(extbytes, 0, m_extensionBytes, 0,
m_extensionBytes.length);
}
m_quotEntityBytes = base.m_quotEntityBytes;
m_ampEntityBytes = base.m_ampEntityBytes;
m_gtEntityBytes = base.m_gtEntityBytes;
m_ltEntityBytes = base.m_ltEntityBytes;
m_cdataStartBytes = base.m_cdataStartBytes;
m_cdataEndBytes = base.m_cdataEndBytes;
}
/**
* Set the byte buffer.
*
* @param buff
*/
public void setBuffer(IOutByteBuffer buff) {
m_byteBuffer = buff;
m_buffer = buff.getBuffer();
m_fillOffset = buff.getOffset();
}
/**
* Get the name of the character encoding used by this writer.
*
* @return encoding
*/
public String getEncodingName() {
return m_encodingName;
}
/**
* Set namespace URIs. This forces a reset of the writer, clearing any
* buffered output. It is intended to be used only for reconfiguring an
* existing writer for reuse.
*
* @param uris ordered array of URIs for namespaces used in document
* @throws IOException
*/
public void setNamespaceUris(String[] uris) throws IOException {
reset();
boolean diff = false;
String[] olds = getNamespaces();
if (olds.length == uris.length) {
for (int i = 0; i < uris.length; i++) {
if (!uris[i].equals(olds[i])) {
diff = true;
break;
}
}
} else {
diff = true;
}
if (diff) {
internalSetUris(uris);
m_prefixBytes = new byte[uris.length][];
defineNamespace(0, "");
defineNamespace(1, "xml");
}
}
/**
* Set nesting indentation. This is advisory only, and implementations of
* this interface are free to ignore it. The intent is to indicate that the
* generated output should use indenting to illustrate element nesting.
*
* @param count number of character to indent per level, or disable
* indentation if negative (zero means new line only)
* @param newline sequence of characters used for a line ending
* (null means use the single character '\n')
* @param indent whitespace character used for indentation
*/
public void setIndentSpaces(int count, String newline, char indent) {
if (count >= 0) {
try {
if (newline == null) {
newline = "\n";
}
m_indent = true;
byte[] base = newline.getBytes(m_encodingName);
m_indentBase = base.length;
byte[] per = new String(new char[]
{ indent }).getBytes(m_encodingName);
m_indentPerLevel = count * per.length;
int length = m_indentBase + m_indentPerLevel * 10;
m_indentSequence = new byte[length];
for (int i = 0; i < length; i++) {
if (i < newline.length()) {
m_indentSequence[i] = base[i];
} else {
int index = (i - m_indentBase) % per.length;
m_indentSequence[i] = per[index];
}
}
} catch (UnsupportedEncodingException e) {
throw new RuntimeException
("Encoding " + m_encodingName + " not recognized by JVM");
}
} else {
m_indent = false;
}
}
/**
* Make at least the requested number of bytes available in the output
* buffer. If necessary, the output buffer will be replaced by a larger
* buffer.
*
* @param length number of bytes space to be made available
* @throws IOException if error writing to document
*/
protected void makeSpace(int length) throws IOException {
if (m_fillOffset + length > m_buffer.length) {
m_byteBuffer.setOffset(m_fillOffset);
m_byteBuffer.free(m_fillOffset, length);
m_buffer = m_byteBuffer.getBuffer();
m_fillOffset = m_byteBuffer.getOffset();
}
}
/**
* Report that namespace has been undefined.
*
* @param index post-translation namespace URI index number
*/
protected void undefineNamespace(int index) {
if (index < m_prefixBytes.length) {
m_prefixBytes[index] = null;
} else if (m_extensionBytes != null) {
index -= m_prefixes.length;
for (int i = 0; i < m_extensionBytes.length; i++) {
int length = m_extensionBytes[i].length;
if (index < length) {
m_extensionBytes[i][index] = null;
break;
} else {
index -= length;
}
}
} else {
throw new IllegalArgumentException("Index out of range");
}
}
/**
* Write namespace prefix to output. This internal method is used to throw
* an exception when an undeclared prefix is used.
*
* @param index namespace URI index number
* @throws IOException if error writing to document
*/
protected void writePrefix(int index) throws IOException {
try {
byte[] bytes = null;
index = translateNamespace(index);
if (index < m_prefixBytes.length) {
bytes = m_prefixBytes[index];
} else if (m_extensionBytes != null) {
index -= m_prefixes.length;
for (int i = 0; i < m_extensionBytes.length; i++) {
int length = m_extensionBytes[i].length;
if (index < length) {
bytes = m_extensionBytes[i][index];
break;
} else {
index -= length;
}
}
}
if (bytes.length > 0) {
makeSpace(bytes.length);
System.arraycopy(bytes, 0, m_buffer, m_fillOffset, bytes.length);
m_fillOffset += bytes.length;
}
} catch (NullPointerException ex) {
throw new IOException("Namespace URI has not been declared.");
}
}
/**
* Write entity bytes to output.
*
* @param bytes actual bytes to be written
* @param offset starting offset in buffer
* @return offset for next data byte in buffer
*/
protected int writeEntity(byte[] bytes, int offset) {
System.arraycopy(bytes, 0, m_buffer, offset, bytes.length);
return offset + bytes.length;
}
/**
* Append extension namespace URIs to those in mapping.
*
* @param uris namespace URIs to extend those in mapping
*/
public void pushExtensionNamespaces(String[] uris) {
super.pushExtensionNamespaces(uris);
byte[][] items = new byte[uris.length][];
if (m_extensionBytes == null) {
m_extensionBytes = new byte[][][] { items };
} else {
int length = m_extensionBytes.length;
byte[][][] grow = new byte[length+1][][];
System.arraycopy(m_extensionBytes, 0, grow, 0, length);
grow[length] = items;
m_extensionBytes = grow;
}
}
/**
* Remove extension namespace URIs. This removes the last set of
* extension namespaces pushed using {@link #pushExtensionNamespaces}.
*/
public void popExtensionNamespaces() {
super.popExtensionNamespaces();
int length = m_extensionBytes.length;
if (length == 1) {
m_extensionBytes = null;
} else {
byte[][][] shrink = new byte[length-1][][];
System.arraycopy(m_extensionBytes, 0, shrink, 0, length-1);
m_extensionBytes = shrink;
}
}
/**
* Request output indent. Output the line end sequence followed by the
* appropriate number of indent characters.
*
* @param bias indent depth difference (positive or negative) from current
* element nesting depth
* @throws IOException on error writing to document
*/
public void indent(int bias) throws IOException {
if (m_indent) {
int length = m_indentBase +
(getNestingDepth() + bias) * m_indentPerLevel;
if (length > 0) {
flagContent();
if (length > m_indentSequence.length) {
int use = Math.max(length,
m_indentSequence.length*2 - m_indentBase);
byte[] grow = new byte[use];
System.arraycopy(m_indentSequence, 0, grow, 0,
m_indentSequence.length);
for (int i = m_indentSequence.length; i < use; i++) {
grow[i] = grow[m_indentBase];
}
m_indentSequence = grow;
}
makeSpace(length);
System.arraycopy(m_indentSequence, 0, m_buffer, m_fillOffset,
length);
m_fillOffset += length;
}
}
}
/**
* Request output indent. Output the line end sequence followed by the
* appropriate number of indent characters for the current nesting level.
*
* @throws IOException on error writing to document
*/
public void indent() throws IOException {
indent(0);
}
/**
* Flush document output. Forces out all output generated to this point.
*
* @throws IOException on error writing to document
*/
public void flush() throws IOException {
flagContent();
m_byteBuffer.setOffset(m_fillOffset);
m_byteBuffer.flush();
m_fillOffset = m_byteBuffer.getOffset();
if (m_baseWriter != null) {
m_baseWriter.m_fillOffset = m_fillOffset;
}
}
/**
* Close document output. Completes writing of document output, including
* closing the output medium.
*
* @throws IOException on error writing to document
*/
public void close() throws IOException {
flush();
m_byteBuffer.finish();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/ISO88591Escaper.java 0000644 0001750 0001750 00000017361 10071714376 025530 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
import java.io.Writer;
import org.jibx.runtime.ICharacterEscaper;
/**
* Handler for writing ASCII output stream. This code is specifically for XML
* 1.0 and would require changes for XML 1.1 (to handle the added legal
* characters, rather than throwing an exception).
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class ISO88591Escaper implements ICharacterEscaper
{
/** Singleton instance of class. */
private static final ISO88591Escaper s_instance = new ISO88591Escaper();
/**
* Private constructor to prevent external creation.
*/
private ISO88591Escaper() {}
/**
* Write attribute value with character entity substitutions. This assumes
* that attributes use the regular quote ('"') delimitor.
*
* @param text attribute value text
* @param writer sink for output text
* @throws IOException on error writing to document
*/
public void writeAttribute(String text, Writer writer) throws IOException {
int mark = 0;
for (int i = 0; i < text.length(); i++) {
char chr = text.charAt(i);
if (chr == '"') {
writer.write(text, mark, i-mark);
mark = i+1;
writer.write(""");
} else if (chr == '&') {
writer.write(text, mark, i-mark);
mark = i+1;
writer.write("&");
} else if (chr == '<') {
writer.write(text, mark, i-mark);
mark = i+1;
writer.write("<");
} else if (chr == '>' && i > 2 && text.charAt(i-1) == ']' &&
text.charAt(i-2) == ']') {
writer.write(text, mark, i-mark-2);
mark = i+1;
writer.write("]]>");
} else if (chr < 0x20) {
if (chr != 0x9 && chr != 0xA && chr != 0xD) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in attribute value text");
}
} else if (chr >= 0x80) {
if (chr < 0xA0 || chr > 0xFF) {
writer.write(text, mark, i-mark);
mark = i+1;
if (chr > 0xD7FF && (chr < 0xE000 || chr == 0xFFFE ||
chr == 0xFFF || chr > 0x10FFFF)) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) +
" in attribute value text");
}
writer.write("&#x");
writer.write(Integer.toHexString(chr));
writer.write(';');
}
}
}
writer.write(text, mark, text.length()-mark);
}
/**
* Write content value with character entity substitutions.
*
* @param text content value text
* @param writer sink for output text
* @throws IOException on error writing to document
*/
public void writeContent(String text, Writer writer) throws IOException {
int mark = 0;
for (int i = 0; i < text.length(); i++) {
char chr = text.charAt(i);
if (chr == '&') {
writer.write(text, mark, i-mark);
mark = i+1;
writer.write("&");
} else if (chr == '<') {
writer.write(text, mark, i-mark);
mark = i+1;
writer.write("<");
} else if (chr == '>' && i > 2 && text.charAt(i-1) == ']' &&
text.charAt(i-2) == ']') {
writer.write(text, mark, i-mark-2);
mark = i+1;
writer.write("]]>");
} else if (chr < 0x20) {
if (chr != 0x9 && chr != 0xA && chr != 0xD) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in content text");
}
} else if (chr >= 0x80) {
if (chr < 0xA0 || chr > 0xFF) {
writer.write(text, mark, i-mark);
mark = i+1;
if (chr > 0xD7FF && (chr < 0xE000 || chr == 0xFFFE ||
chr == 0xFFF || chr > 0x10FFFF)) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in content text");
}
writer.write("&#x");
writer.write(Integer.toHexString(chr));
writer.write(';');
}
}
}
writer.write(text, mark, text.length()-mark);
}
/**
* Write CDATA to document. This writes the beginning and ending sequences
* for a CDATA section as well as the actual text, verifying that only
* characters allowed by the encoding are included in the text.
*
* @param text content value text
* @param writer sink for output text
* @throws IOException on error writing to document
*/
public void writeCData(String text, Writer writer) throws IOException {
writer.write("' && i > 2 && text.charAt(i-1) == ']' &&
text.charAt(i-2) == ']') {
throw new IOException("Sequence \"]]>\" is not allowed " +
"within CDATA section text");
} else if (chr < 0x20) {
if (chr != 0x9 && chr != 0xA && chr != 0xD) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in CDATA section");
}
} else if (chr >= 0x80 && (chr < 0xA0 || chr > 0xFF)) {
throw new IOException("Character code 0x" +
Integer.toHexString(chr) +
" not supported by encoding in CDATA section");
}
}
writer.write(text);
writer.write("]]>");
}
/**
* Get instance of escaper.
*
* @return escaper instance
*/
public static ICharacterEscaper getInstance() {
return s_instance;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/UTF8Escaper.java 0000644 0001750 0001750 00000016004 10231200600 025150 0 ustar twerner twerner /*
Copyright (c) 2004-2005, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
import java.io.Writer;
import org.jibx.runtime.ICharacterEscaper;
/**
* Handler for writing UTF output stream (for any form of UTF, despite the
* name). This code is specifically for XML 1.0 and would require changes for
* XML 1.1 (to handle the added legal characters, rather than throwing an
* exception).
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class UTF8Escaper implements ICharacterEscaper
{
/** Singleton instance of class. */
private static final UTF8Escaper s_instance = new UTF8Escaper();
/**
* Private constructor to prevent external creation.
*/
private UTF8Escaper() {}
/**
* Write attribute value with character entity substitutions. This assumes
* that attributes use the regular quote ('"') delimitor.
*
* @param text attribute value text
* @param writer sink for output text
* @throws IOException on error writing to document
*/
public void writeAttribute(String text, Writer writer) throws IOException {
int mark = 0;
for (int i = 0; i < text.length(); i++) {
char chr = text.charAt(i);
if (chr == '"') {
writer.write(text, mark, i-mark);
mark = i+1;
writer.write(""");
} else if (chr == '&') {
writer.write(text, mark, i-mark);
mark = i+1;
writer.write("&");
} else if (chr == '<') {
writer.write(text, mark, i-mark);
mark = i+1;
writer.write("<");
} else if (chr == '>' && i > 2 && text.charAt(i-1) == ']' &&
text.charAt(i-2) == ']') {
writer.write(text, mark, i-mark-2);
mark = i+1;
writer.write("]]>");
} else if (chr < 0x20) {
if (chr != 0x9 && chr != 0xA && chr != 0xD) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in attribute value text");
}
} else if (chr > 0xD7FF && (chr < 0xE000 || chr == 0xFFFE ||
chr == 0xFFFF || chr > 0x10FFFF)) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in attribute value text");
}
}
writer.write(text, mark, text.length()-mark);
}
/**
* Write content value with character entity substitutions.
*
* @param text content value text
* @param writer sink for output text
* @throws IOException on error writing to document
*/
public void writeContent(String text, Writer writer) throws IOException {
int mark = 0;
for (int i = 0; i < text.length(); i++) {
char chr = text.charAt(i);
if (chr == '&') {
writer.write(text, mark, i-mark);
mark = i+1;
writer.write("&");
} else if (chr == '<') {
writer.write(text, mark, i-mark);
mark = i+1;
writer.write("<");
} else if (chr == '>' && i > 2 && text.charAt(i-1) == ']' &&
text.charAt(i-2) == ']') {
writer.write(text, mark, i-mark-2);
mark = i+1;
writer.write("]]>");
} else if (chr < 0x20) {
if (chr != 0x9 && chr != 0xA && chr != 0xD) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in content text");
}
} else if (chr > 0xD7FF && (chr < 0xE000 || chr == 0xFFFE ||
chr == 0xFFFF || chr > 0x10FFFF)) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in content text");
}
}
writer.write(text, mark, text.length()-mark);
}
/**
* Write CDATA to document. This writes the beginning and ending sequences
* for a CDATA section as well as the actual text, verifying that only
* characters allowed by the encoding are included in the text.
*
* @param text content value text
* @param writer sink for output text
* @throws IOException on error writing to document
*/
public void writeCData(String text, Writer writer) throws IOException {
writer.write("' && i > 2 && text.charAt(i-1) == ']' &&
text.charAt(i-2) == ']') {
throw new IOException("Sequence \"]]>\" is not allowed " +
"within CDATA section text");
} else if (chr < 0x20) {
if (chr != 0x9 && chr != 0xA && chr != 0xD) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in CDATA section");
}
} else if (chr > 0xD7FF &&
(chr < 0xE000 || chr == 0xFFFE || chr == 0xFFFF)) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in CDATA section");
}
}
writer.write(text);
writer.write("]]>");
}
/**
* Get instance of escaper.
*
* @return escaper instance
*/
public static ICharacterEscaper getInstance() {
return s_instance;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/UTF8StreamWriter.java 0000644 0001750 0001750 00000034100 11065007470 026233 0 ustar twerner twerner /*
Copyright (c) 2004-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
import org.jibx.runtime.IXMLWriter;
/**
* Handler for marshalling text document to a UTF-8 output stream.
*
* @author Dennis M. Sosnoski
*/
public class UTF8StreamWriter extends StreamWriterBase
{
/** Conversion buffer for prefixes; */
private byte[] m_converts;
/**
* Constructor with supplied buffer.
*
* @param uris ordered array of URIs for namespaces used in document (must
* be constant; the value in position 0 must always be the empty string "",
* and the value in position 1 must always be the XML namespace
* "http://www.w3.org/XML/1998/namespace")
*/
public UTF8StreamWriter(String[] uris) {
super("UTF-8", uris);
defineNamespace(0, "");
defineNamespace(1, "xml");
}
/**
* Copy constructor. This takes the stream from a supplied instance, while
* setting a new array of namespace URIs. It's intended for use when
* invoking one binding from within another binding.
*
* @param base instance to be used as base for writer
* @param uris ordered array of URIs for namespaces used in document
* (see {@link #UTF8StreamWriter(String[])})
*/
public UTF8StreamWriter(UTF8StreamWriter base, String[] uris) {
super(base, uris);
defineNamespace(0, "");
defineNamespace(1, "xml");
}
/**
* Write markup text to output. Markup text can be written directly to the
* output without the need for any escaping, but still needs to be properly
* encoded.
*
* @param text markup text to be written
* @throws IOException if error writing to document
*/
protected void writeMarkup(String text) throws IOException {
int length = text.length();
makeSpace(length * 3);
int fill = m_fillOffset;
for (int i = 0; i < length; i++) {
char chr = text.charAt(i);
if (chr > 0x7F) {
if (chr > 0x7FF) {
m_buffer[fill++] = (byte)(0xE0 + (chr >> 12));
m_buffer[fill++] = (byte)(0x80 + ((chr >> 6) & 0x3F));
m_buffer[fill++] = (byte)(0x80 + (chr & 0x3F));
} else {
m_buffer[fill++] = (byte)(0xC0 + (chr >> 6));
m_buffer[fill++] = (byte)(0x80 + (chr & 0x3F));
}
} else {
m_buffer[fill++] = (byte)chr;
}
}
m_fillOffset = fill;
}
/**
* Write markup character to output. Markup text can be written directly to
* the output without the need for any escaping, but still needs to be
* properly encoded.
*
* @param chr markup character to be written
* @throws IOException if error writing to document
*/
protected void writeMarkup(char chr) throws IOException {
makeSpace(3);
if (chr > 0x7F) {
if (chr > 0x7FF) {
m_buffer[m_fillOffset++] = (byte)(0xE0 + (chr >> 12));
m_buffer[m_fillOffset++] = (byte)(0x80 + ((chr >> 6) & 0x3F));
m_buffer[m_fillOffset++] = (byte)(0x80 + (chr & 0x3F));
} else {
m_buffer[m_fillOffset++] = (byte)(0xC0 + (chr >> 6));
m_buffer[m_fillOffset++] = (byte)(0x80 + (chr & 0x3F));
}
} else {
m_buffer[m_fillOffset++] = (byte)chr;
}
}
/**
* Report that namespace has been defined.
*
* @param index post-translation namespace URI index number
* @param prefix prefix used for namespace
*/
protected void defineNamespace(int index, String prefix) {
int limit = prefix.length() * 3;
if (m_converts == null) {
m_converts = new byte[limit];
} else if (limit > m_converts.length) {
m_converts = new byte[limit];
}
int fill = 0;
for (int i = 0; i < prefix.length(); i++) {
char chr = prefix.charAt(i);
if (chr > 0x7F) {
if (chr > 0x7FF) {
m_converts[fill++] = (byte)(0xE0 + (chr >> 12));
m_converts[fill++] = (byte)(0x80 + ((chr >> 6) & 0x3F));
m_converts[fill++] = (byte)(0x80 + (chr & 0x3F));
} else {
m_converts[fill++] = (byte)(0xC0 + (chr >> 6));
m_converts[fill++] = (byte)(0x80 + (chr & 0x3F));
}
} else {
m_converts[fill++] = (byte)chr;
}
}
byte[] trim;
if (fill > 0) {
trim = new byte[fill+1];
System.arraycopy(m_converts, 0, trim, 0, fill);
trim[fill] = ':';
} else {
trim = new byte[0];
}
if (index < m_prefixBytes.length) {
m_prefixBytes[index] = trim;
} else if (m_extensionBytes != null) {
index -= m_prefixBytes.length;
for (int i = 0; i < m_extensionBytes.length; i++) {
int length = m_extensionBytes[i].length;
if (index < length) {
m_extensionBytes[i][index] = trim;
} else {
index -= length;
}
}
} else {
throw new IllegalArgumentException("Index out of range");
}
}
/**
* Write attribute text to output. This needs to write the text with any
* appropriate escaping.
*
* @param text attribute value text to be written
* @throws IOException if error writing to document
*/
protected void writeAttributeText(String text) throws IOException {
int length = text.length();
makeSpace(length * 6);
int fill = m_fillOffset;
for (int i = 0; i < length; i++) {
char chr = text.charAt(i);
if (chr == '"') {
fill = writeEntity(m_quotEntityBytes, fill);
} else if (chr == '&') {
fill = writeEntity(m_ampEntityBytes, fill);
} else if (chr == '<') {
fill = writeEntity(m_ltEntityBytes, fill);
} else if (chr == '>' && i > 2 && text.charAt(i-1) == ']' &&
text.charAt(i-2) == ']') {
m_buffer[fill++] = (byte)']';
m_buffer[fill++] = (byte)']';
fill = writeEntity(m_gtEntityBytes, fill);
} else if (chr < 0x20) {
if (chr != 0x9 && chr != 0xA && chr != 0xD) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in attribute value text");
} else {
m_buffer[fill++] = (byte)chr;
}
} else {
if (chr > 0x7F) {
if (chr > 0x7FF) {
if (chr > 0xD7FF && (chr < 0xE000 || chr == 0xFFFE ||
chr == 0xFFFF || chr > 0x10FFFF)) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) +
" in attribute value text");
} else {
m_buffer[fill++] = (byte)(0xE0 + (chr >> 12));
m_buffer[fill++] =
(byte)(0x80 + ((chr >> 6) & 0x3F));
m_buffer[fill++] = (byte)(0x80 + (chr & 0x3F));
}
} else {
m_buffer[fill++] = (byte)(0xC0 + (chr >> 6));
m_buffer[fill++] = (byte)(0x80 + (chr & 0x3F));
}
} else {
m_buffer[fill++] = (byte)chr;
}
}
}
m_fillOffset = fill;
}
/**
* Write ordinary character data text content to document.
*
* @param text content value text
* @throws IOException on error writing to document
*/
public void writeTextContent(String text) throws IOException {
flagTextContent();
int length = text.length();
makeSpace(length * 5);
int fill = m_fillOffset;
for (int i = 0; i < length; i++) {
char chr = text.charAt(i);
if (chr == '&') {
fill = writeEntity(m_ampEntityBytes, fill);
} else if (chr == '<') {
fill = writeEntity(m_ltEntityBytes, fill);
} else if (chr == '>' && i > 2 && text.charAt(i-1) == ']' &&
text.charAt(i-2) == ']') {
fill = writeEntity(m_gtEntityBytes, fill);
} else if (chr < 0x20) {
if (chr != 0x9 && chr != 0xA && chr != 0xD) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in content text");
} else {
m_buffer[fill++] = (byte)chr;
}
} else {
if (chr > 0x7F) {
if (chr > 0x7FF) {
if (chr > 0xD7FF && (chr < 0xE000 || chr == 0xFFFE ||
chr == 0xFFFF || chr > 0x10FFFF)) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in content text");
} else {
m_buffer[fill++] = (byte)(0xE0 + (chr >> 12));
m_buffer[fill++] =
(byte)(0x80 + ((chr >> 6) & 0x3F));
m_buffer[fill++] = (byte)(0x80 + (chr & 0x3F));
}
} else {
m_buffer[fill++] = (byte)(0xC0 + (chr >> 6));
m_buffer[fill++] = (byte)(0x80 + (chr & 0x3F));
}
} else {
m_buffer[fill++] = (byte)chr;
}
}
}
m_fillOffset = fill;
}
/**
* Write CDATA text to document.
*
* @param text content value text
* @throws IOException on error writing to document
*/
public void writeCData(String text) throws IOException {
flagTextContent();
int length = text.length();
makeSpace(length * 3 + 12);
int fill = m_fillOffset;
fill = writeEntity(m_cdataStartBytes, fill);
for (int i = 0; i < length; i++) {
char chr = text.charAt(i);
if (chr == '>' && i > 2 && text.charAt(i-1) == ']' &&
text.charAt(i-2) == ']') {
throw new IOException("Sequence \"]]>\" is not allowed " +
"within CDATA section text");
} else if (chr < 0x20) {
if (chr != 0x9 && chr != 0xA && chr != 0xD) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in content text");
} else {
m_buffer[fill++] = (byte)chr;
}
} else {
if (chr > 0x7F) {
if (chr > 0x7FF) {
if (chr > 0xD7FF && (chr < 0xE000 || chr == 0xFFFE ||
chr == 0xFFFF || chr > 0x10FFFF)) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) +
" in CDATA section text");
} else {
m_buffer[fill++] = (byte)(0xE0 + (chr >> 12));
m_buffer[fill++] =
(byte)(0x80 + ((chr >> 6) & 0x3F));
m_buffer[fill++] = (byte)(0x80 + (chr & 0x3F));
}
} else {
m_buffer[fill++] = (byte)(0xC0 + (chr >> 6));
m_buffer[fill++] = (byte)(0x80 + (chr & 0x3F));
}
} else {
m_buffer[fill++] = (byte)chr;
}
}
}
m_fillOffset = writeEntity(m_cdataEndBytes, fill);
}
/**
* Create a child writer instance to be used for a separate binding. The
* child writer inherits the stream and encoding from this writer, while
* using the supplied namespace URIs.
*
* @param uris ordered array of URIs for namespaces used in document
* (see {@link #UTF8StreamWriter(String[])})
* @return child writer
* @throws IOException
*/
public IXMLWriter createChildWriter(String[] uris) throws IOException {
flagContent();
return new UTF8StreamWriter(this, uris);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/UnmarshallingContext.java 0000644 0001750 0001750 00000365215 11256241372 027326 0 ustar twerner twerner /*
Copyright (c) 2002-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.InputStream;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IUnmarshaller;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.IXMLReader;
import org.jibx.runtime.JiBXConstrainedParseException;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.JiBXParseException;
import org.jibx.runtime.Utility;
/**
* Pull parser wrapper supplying convenience methods for access. Most of
* these methods are designed for use in code generated by the binding
* generator.
*
* @author Dennis M. Sosnoski
*/
public class UnmarshallingContext implements IUnmarshallingContext
{
/** Starting size for object stack. */
private static final int INITIAL_STACK_SIZE = 20;
/** Factory for creating XML readers. */
private static final IXMLReaderFactory s_readerFactory =
RuntimeSupport.loadFactory();
/** Binding factory used to create this unmarshaller. */
private IBindingFactory m_factory;
/** Map from fully-qualified class name to index in internal tables. */
private StringIntHashMap m_classIndexMap;
/** Parser in use. */
private IXMLReader m_reader;
/** Index past end of last fixed marshaller class. */
private int m_transientBase;
/** Transient unmarshaller classes for mapping definition (null
for mappings out of context). */
private String[] m_transientUnmarshallerClasses;
//
// Structures organized by mapping index number. Each unmarshaller in the
// binding definition is assigned a unique index number by the binding
// compiler. This includes both generated unmarshallers (from non-abstract
// definitions) and user-defined unmarshallers. Instances of
// the unmarshaller classes are created as needed. The indexes for the
// unmarshallers corresponding to named mappings always precede those for
// internal mappings in the list.
/** Unmarshallers for classes in mapping definition (lazy create of actual
unmarshaller instances) */
protected IUnmarshaller[] m_unmarshallers;
//
// Structures organized by mapping
/** Namespaces for elements associated with class mappings. */
protected String[] m_namespaces;
/** Names for elements associated with class mappings. */
protected String[] m_names;
/** ID maps for finding references. */
protected Map[] m_idMaps;
/** Class names of referenced types (null unless class-specific
IDs used). */
protected String[] m_idClasses;
/** Current unmarshalling stack depth. */
protected int m_stackDepth;
/** Stack of objects being unmarshalled. */
protected Object[] m_objectStack;
/** Mapping from element name to class index for global mappings (cached
from binding factory). Entries are Integer values if single
match, int[] if multiple matches, giving the mapping index. */
protected Map m_unmarshalMap;
/** Mapping from element name to class index for transient mappings. Entries
are Integer values if single match, ArrayList if
multiple matches, giving the mapping index. */
protected Map m_transientUnmarshalMap;
/** Last IDREF value parsed. */
protected String m_idref;
/** User context object (not used by JiBX, only for user convenience). */
protected Object m_userContext;
/**
* Constructor. Builds the actual parser and initializes internal data
* structures.
*
* @param nmap number of mapping definitions included
* @param umcs names of unmarshaller classes for indexes with fixed
* unmarshallers (as opposed to mapping slots, which may be overridden;
* reference kept, must be constant)
* @param nss namespaces for elements of classes with global definitions
* @param names names for elements of classes with global definitions
* @param idcs array of class names with IDs (null if no IDs or
* global IDs)
* @param ifact binding factory creating this unmarshaller
*/
public UnmarshallingContext(int nmap, String[] umcs, String[] nss,
String[] names, String[] idcs, IBindingFactory ifact) {
// initialize internal unmarshaller state
m_transientBase = nmap - umcs.length;
m_transientUnmarshallerClasses = new String[nmap-m_transientBase];
m_unmarshallers = new IUnmarshaller[nmap];
m_namespaces = new String[nmap];
System.arraycopy(nss, 0, m_namespaces, 0, nss.length);
m_names = new String[nmap];
System.arraycopy(names, 0, m_names, 0, names.length);
m_idClasses = idcs;
int size = idcs == null ? 1 : idcs.length;
m_idMaps = new HashMap[size];
m_objectStack = new Object[INITIAL_STACK_SIZE];
m_factory = ifact;
if (ifact != null) {
m_classIndexMap = ifact.getClassIndexMap();
} else {
m_classIndexMap = new StringIntHashMap();
}
}
/**
* Default constructor. This can be used for creating a context outside of
* the generated code for special purposes.
*/
public UnmarshallingContext() {
this(0, Utility.EMPTY_STRING_ARRAY, Utility.EMPTY_STRING_ARRAY,
Utility.EMPTY_STRING_ARRAY, Utility.EMPTY_STRING_ARRAY, null);
}
/**
* Build name with optional namespace. Just returns the appropriate
* name format.
*
* @param ns namespace URI of name
* @param name local name part of name
* @return formatted name string
*/
public static String buildNameString(String ns, String name) {
if (ns == null || "".equals(ns)) {
return "\"" + name + "\"";
} else {
return "\"{" + ns + "}" + name + "\"";
}
}
/**
* Build current element name, with optional namespace.
*
* @return formatted name string
*/
public String currentNameString() {
return buildNameString(m_reader.getNamespace(), m_reader.getName());
}
/**
* Build current parse input position description.
*
* @return text description of current parse position
*/
public String buildPositionString() {
return m_reader.buildPositionString();
}
/**
* Throw exception for expected element start tag not found.
*
* @param ns namespace URI of name
* @param name local name part of name
* @exception JiBXException always thrown
*/
public void throwStartTagNameError(String ns, String name)
throws JiBXException {
throw new JiBXException("Expected " + buildNameString(ns, name) +
" start tag, found " + currentNameString() + " start tag " +
buildPositionString());
}
/**
* Throw exception for expected element end tag not found.
*
* @param ns namespace URI of name
* @param name local name part of name
* @exception JiBXException always thrown
*/
public void throwEndTagNameError(String ns, String name)
throws JiBXException {
throw new JiBXException("Expected " + buildNameString(ns, name) +
" end tag, found " + currentNameString() + " end tag " +
buildPositionString());
}
/**
* Throw exception including a name and position information.
*
* @param msg leading message text
* @param ns namespace URI of name
* @param name local name part of name
* @exception JiBXException always thrown
*/
public void throwNameException(String msg, String ns, String name)
throws JiBXException {
throw new JiBXException(msg + buildNameString(ns, name) +
buildPositionString());
}
/**
* Advance to next parse item. This wraps the base parser call in order to
* catch and handle exceptions.
*
* @exception JiBXException on any error (possibly wrapping other exception)
*/
private void advance() throws JiBXException {
m_reader.nextToken();
}
/**
* Verify namespace. This is a simple utility method that allows multiple
* representations for the empty namespace as a convenience for generated
* code.
*
* @param ns namespace URI expected (may be null
* or the empty string for the empty namespace)
* @return true if the current namespace matches that
* expected, false if not
*/
private boolean verifyNamespace(String ns) {
if (ns == null || "".equals(ns)) {
return m_reader.getNamespace().length() == 0;
} else {
return ns.equals(m_reader.getNamespace());
}
}
/**
* Get attribute value from parser.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @return attribute value text, or null if missing
*/
private String getAttributeValue(String ns, String name) {
return m_reader.getAttributeValue(ns, name);
}
/**
* Set document to be parsed from stream. This call is not part of the
* interface definition, but is supplied to allow direct control of the
* namespace processing by the compiler. The option of disabling namespaces
* should be considered experimental and may not be supported in the future.
*
* @param ins stream supplying document data
* @param name document name (null if unknown)
* @param enc document input encoding, or null if to be
* determined by parser
* @param nsa enable namespace processing for parser flag
* @throws JiBXException if error creating parser
*/
public void setDocument(InputStream ins, String name, String enc,
boolean nsa) throws JiBXException {
if (m_reader == null) {
m_reader = s_readerFactory.createReader(ins, name, enc, nsa);
} else {
m_reader = s_readerFactory.recycleReader(m_reader, ins, name, enc);
}
reset();
}
/**
* Set document to be parsed from stream.
*
* @param ins stream supplying document data
* @param enc document input encoding, or null if to be
* determined by parser
* @throws JiBXException if error creating parser
*/
public void setDocument(InputStream ins, String enc) throws JiBXException {
setDocument(ins, null, enc, true);
}
/**
* Set document to be parsed from reader. This call is not part of the
* interface definition, but is supplied to allow direct control of the
* namespace processing by the compiler. The option of disabling namespaces
* should be considered experimental and may not be supported in the future.
*
* @param rdr reader supplying document data
* @param name document name (null if unknown)
* @param nsa enable namespace processing for parser flag
* @throws JiBXException if error creating parser
*/
public void setDocument(Reader rdr, String name, boolean nsa)
throws JiBXException {
if (m_reader == null) {
m_reader = s_readerFactory.createReader(rdr, name, nsa);
} else {
m_reader = s_readerFactory.recycleReader(m_reader, rdr, name);
}
reset();
}
/**
* Set document to be parsed from reader.
*
* @param rdr reader supplying document data
* @throws JiBXException if error creating parser
*/
public void setDocument(Reader rdr) throws JiBXException {
setDocument(rdr, null, true);
}
/**
* Set named document to be parsed from stream.
*
* @param ins stream supplying document data
* @param name document name
* @param enc document input encoding, or null if to be
* determined by parser
* @throws JiBXException if error creating parser
*/
public void setDocument(InputStream ins, String name, String enc)
throws JiBXException {
setDocument(ins, name, enc, true);
}
/**
* Set named document to be parsed from reader.
*
* @param rdr reader supplying document data
* @param name document name
* @throws JiBXException if error creating parser
*/
public void setDocument(Reader rdr, String name) throws JiBXException {
setDocument(rdr, name, true);
}
/**
* Set input document parse source directly.
*
* @param rdr document parse event reader
*/
public void setDocument(IXMLReader rdr) {
m_reader = rdr;
}
/**
* Initializes the context to use the same parser and document as another
* unmarshalling context. This method is designed for use when an initial
* context needs to create and invoke a secondary context in the course of
* an unmarshalling operation.
*
* @param parent context supplying parser and document to be unmarshalled
*/
public void setFromContext(UnmarshallingContext parent) {
m_reader = parent.m_reader;
}
/**
* Reset unmarshalling information. This releases all references to
* unmarshalled objects and prepares the context for potential reuse.
* It is automatically called when input is set.
*/
public void reset() {
for (int i = 0; i < m_idMaps.length; i++) {
m_idMaps[i] = null;
}
for (int i = 0; i < m_transientUnmarshallerClasses.length; i++) {
if (m_transientUnmarshallerClasses[i] != null) {
m_transientUnmarshallerClasses[i] = null;
m_namespaces[i+m_transientBase] = null;
m_names[i+m_transientBase] = null;
}
m_unmarshallers[i] = null;
}
if (m_transientUnmarshalMap != null) {
m_transientUnmarshalMap.clear();
}
m_idref = null;
for (int i = 0; i < m_objectStack.length; i++) {
m_objectStack[i] = null;
}
m_stackDepth = 0;
m_userContext = null;
}
/**
* Parse to start tag. Ignores character data seen prior to a start tag, but
* throws exception if an end tag or the end of the document is seen before
* a start tag. Leaves the parser positioned at the start tag.
*
* @return element name of start tag found
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public String toStart() throws JiBXException {
if (m_reader.getEventType() == IXMLReader.START_TAG) {
return m_reader.getName();
}
while (true) {
m_reader.next();
switch (m_reader.getEventType()) {
case IXMLReader.START_TAG:
return m_reader.getName();
case IXMLReader.END_TAG:
throw new JiBXException("Expected start tag, " +
"found end tag " + currentNameString() +
" " + buildPositionString());
case IXMLReader.END_DOCUMENT:
throw new JiBXException("Expected start tag, " +
"found end of document " + buildPositionString());
}
}
}
/**
* Parse to end tag. Ignores character data seen prior to an end tag, but
* throws exception if a start tag or the end of the document is seen before
* an end tag. Leaves the parser positioned at the end tag.
*
* @return element name of end tag found
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public String toEnd() throws JiBXException {
if (m_reader.getEventType() == IXMLReader.END_TAG) {
return m_reader.getName();
}
while (true) {
m_reader.next();
switch (m_reader.getEventType()) {
case IXMLReader.START_TAG:
throw new JiBXException("Expected end tag, " +
"found start tag " + currentNameString() +
" " + buildPositionString());
case IXMLReader.END_TAG:
return m_reader.getName();
case IXMLReader.END_DOCUMENT:
throw new JiBXException("Expected end tag, " +
"found end of document " + buildPositionString());
}
}
}
/**
* Parse to start or end tag. If not currently positioned at a start or end
* tag this first advances the parse to the next start or end tag.
*
* @return parser event type for start tag or end tag
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public int toTag() throws JiBXException {
int type = m_reader.getEventType();
while (type != IXMLReader.START_TAG &&
type != IXMLReader.END_TAG) {
type = m_reader.next();
}
return m_reader.getEventType();
}
/**
* Check if next tag is start of element. If not currently positioned at a
* start or end tag this first advances the parse to the next start or end
* tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param name element name expected
* @return true if at start of element with supplied name,
* false if not
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public boolean isAt(String ns, String name) throws JiBXException {
int type = m_reader.getEventType();
while (type != IXMLReader.START_TAG &&
type != IXMLReader.END_TAG) {
type = m_reader.next();
}
return m_reader.getEventType() == IXMLReader.START_TAG &&
m_reader.getName().equals(name) && verifyNamespace(ns);
}
/**
* Check if attribute is present on current start tag. Throws an exception
* if not currently positioned on a start tag.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @return true if named attribute is present,
* false if not
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public boolean hasAttribute(String ns, String name) throws JiBXException {
if (m_reader.getEventType() == IXMLReader.START_TAG) {
return getAttributeValue(ns, name) != null;
} else {
throw new JiBXException("Error parsing document " +
buildPositionString());
}
}
/**
* Check if any of several attributes is present on current start tag.
* Throws an exception if not currently positioned on a start tag.
*
* @param nss namespace URIs for expected attributes (each may be
* null or the empty string for the empty namespace)
* @param names attribute names expected
* @return true if at least one of the named attributes is
* present, false if not
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public boolean hasAnyAttribute(String[] nss, String[] names)
throws JiBXException {
if (m_reader.getEventType() == IXMLReader.START_TAG) {
for (int i = 0; i < names.length; i++) {
if (getAttributeValue(nss[i], names[i]) != null) {
return true;
}
}
return false;
} else {
throw new JiBXException("Error parsing document " +
buildPositionString());
}
}
/**
* Check that only allowed attributes are present on current start tag.
* Throws an exception if not currently positioned on a start tag, or if
* an attribute is present which is not in the list.
*
* @param nss namespace URIs for allowed attributes (each may be
* null or the empty string for the empty namespace)
* @param names alphabetical list of attribute names expected (duplicates
* names are ordered by namespace URI)
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public void checkAllowedAttributes(String[] nss, String[] names)
throws JiBXException {
if (m_reader.getEventType() == IXMLReader.START_TAG) {
int count = m_reader.getAttributeCount();
loop: for (int i = 0; i < count; i++) {
String name = m_reader.getAttributeName(i);
String ns = m_reader.getAttributeNamespace(i);
int base = 0;
int limit = names.length - 1;
while (base <= limit) {
int cur = (base + limit) >> 1;
int diff = name.compareTo(names[cur]);
if (diff == 0) {
String comp = nss[cur];
if (comp == null) {
diff = ns.compareTo("");
} else {
diff = ns.compareTo(comp);
}
if (diff == 0) {
continue loop;
}
}
if (diff < 0) {
limit = cur - 1;
} else if (diff > 0) {
base = cur + 1;
}
}
throwStartTagException("Illegal attribute " +
buildNameString(ns, name));
}
} else {
throw new JiBXException("Error parsing document " +
buildPositionString());
}
}
/**
* Internal parse to expected start tag. Ignores character data seen prior
* to a start tag, but throws exception if an end tag or the end of the
* document is seen before a start tag. Leaves the parser positioned at the
* start tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param name element name expected
* @throws JiBXException on any error (possibly wrapping other exception)
*/
private void matchStart(String ns, String name) throws JiBXException {
if (toTag() == IXMLReader.START_TAG) {
if (!m_reader.getName().equals(name) || !verifyNamespace(ns)) {
throwStartTagNameError(ns, name);
}
} else {
throw new JiBXException("Expected " + buildNameString(ns, name)
+ " start tag, found " + currentNameString() + " end tag "
+ buildPositionString());
}
}
/**
* Parse to start of element. Ignores character data to next start or end
* tag, but throws exception if an end tag is seen before a start tag, or if
* the start tag seen does not match the expected name. Leaves the parse
* positioned at the start tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param name element name expected
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public void parseToStartTag(String ns, String name) throws JiBXException {
matchStart(ns, name);
}
/**
* Parse past start of element. Ignores character data to next start or end
* tag, but throws exception if an end tag is seen before a start tag, or if
* the start tag seen does not match the expected name. Leaves the parse
* positioned following the start tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param name element name expected
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public void parsePastStartTag(String ns, String name) throws JiBXException {
matchStart(ns, name);
advance();
}
/**
* Parse past start of expected element. If not currently positioned at a
* start or end tag this first advances the parser to the next tag. If the
* expected start tag is found it is skipped and the parse is left
* positioned following the start tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param name element name expected
* @return true if start tag found, false if not
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public boolean parseIfStartTag(String ns, String name)
throws JiBXException {
if (isAt(ns, name)) {
advance();
return true;
} else {
return false;
}
}
/**
* Parse past current end of element. Ignores character data to next start
* or end tag, but throws exception if a start tag is seen before a end tag,
* or if the end tag seen does not match the expected name. Leaves the parse
* positioned following the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param name element name expected
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public void parsePastCurrentEndTag(String ns, String name)
throws JiBXException {
// move parse to start or end tag
int event = toTag();
// check for match on expected end tag
if (event == IXMLReader.END_TAG) {
if (m_reader.getName().equals(name) && verifyNamespace(ns)) {
advance();
} else {
throwEndTagNameError(ns, name);
}
} else {
throw new JiBXException("Expected " + buildNameString(ns, name)
+ " end tag, found " + currentNameString() + " start tag "
+ buildPositionString());
}
}
/**
* Parse past end of element. If currently at a start tag parses past that
* start tag, then ignores character data to next start or end tag, and
* throws exception if a start tag is seen before a end tag, or if
* the end tag seen does not match the expected name. Leaves the parse
* positioned following the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param name element name expected
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public void parsePastEndTag(String ns, String name) throws JiBXException {
// most past current tag if start
int event = m_reader.getEventType();
if (event == IXMLReader.START_TAG) {
advance();
}
// handle as current tag
parsePastCurrentEndTag(ns, name);
}
/**
* Check if next tag is a start tag. If not currently positioned at a
* start or end tag this first advances the parse to the next start or
* end tag.
*
* @return true if at start of element, false if
* at end
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public boolean isStart() throws JiBXException {
int type = m_reader.getEventType();
while (type != IXMLReader.START_TAG &&
type != IXMLReader.END_TAG && type != IXMLReader.END_DOCUMENT) {
type = m_reader.next();
}
return m_reader.getEventType() == IXMLReader.START_TAG;
}
/**
* Check if next tag is an end tag. If not currently positioned at a
* start or end tag this first advances the parse to the next start or
* end tag.
*
* @return true if at end of element, false if
* at start
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public boolean isEnd() throws JiBXException {
int type = m_reader.getEventType();
while (type != IXMLReader.START_TAG &&
type != IXMLReader.END_TAG) {
type = m_reader.next();
}
return m_reader.getEventType() == IXMLReader.END_TAG;
}
/**
* Accumulate text content. This skips past comments and processing
* instructions, and consolidates text and entities to a single string. Any
* unexpanded entity references found are treated as errors.
*
* @return consolidated text string (empty string if no text components)
* @exception JiBXException on error in unmarshalling
*/
public String accumulateText() throws JiBXException {
String text = null;
StringBuffer buff = null;
loop: while (true) {
switch (m_reader.getEventType()) {
case IXMLReader.ENTITY_REF:
if (m_reader.getText() == null) {
throw new JiBXException
("Unexpanded entity reference in text at " +
buildPositionString());
}
// fall through into text accumulation
case IXMLReader.CDSECT:
case IXMLReader.TEXT:
if (text == null) {
text = m_reader.getText();
} else {
if (buff == null) {
buff = new StringBuffer(text);
}
buff.append(m_reader.getText());
}
break;
case IXMLReader.END_TAG:
case IXMLReader.START_TAG:
case IXMLReader.END_DOCUMENT:
break loop;
default:
break;
}
m_reader.nextToken();
}
if (buff == null) {
return (text == null) ? "" : text;
} else {
return buff.toString();
}
}
/**
* Parse required text content. Assumes the parse is already positioned at
* the text content, so just returns the text.
*
* @return content text found
* @throws JiBXException on any error (possible wrapping other exception)
*/
public String parseContentText() throws JiBXException {
return accumulateText();
}
/**
* Parse past end of element, returning optional text content. Assumes
* you've already parsed past the start tag of the element, so it just looks
* for text content followed by the end tag, and returns with the parser
* positioned after the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @return content text from element
* @throws JiBXException on any error (possible wrapping other exception)
*/
public String parseContentText(String ns, String tag)
throws JiBXException {
String text = accumulateText();
switch (m_reader.getEventType()) {
case IXMLReader.END_TAG:
if (m_reader.getName().equals(tag) &&
verifyNamespace(ns)) {
m_reader.nextToken();
return text;
} else {
throwEndTagNameError(ns, tag);
}
case IXMLReader.START_TAG:
throw new JiBXException("Expected " +
buildNameString(ns, tag) + " end tag, " +
"found " + currentNameString() + " start tag " +
buildPositionString());
case IXMLReader.END_DOCUMENT:
throw new JiBXException("Expected " +
buildNameString(ns, tag) + " end tag, " +
"found end of document " + buildPositionString());
}
return null;
}
/**
* Parse past end of element, returning integer value of
* content. Assumes you've already parsed past the start tag of the
* element, so it just looks for text content followed by the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @return converted value from element text
* @throws JiBXException on any error (possible wrapping other exception)
*/
public int parseContentInt(String ns, String tag) throws JiBXException {
String text = parseContentText(ns, tag);
try {
return Utility.parseInt(text);
} catch (JiBXException ex) {
throw new JiBXParseException(ex.getMessage() + ' ' +
buildPositionString(), text, ns, tag, ex.getRootCause());
}
}
/**
* Parse entire element, returning text content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @return content text from element
* @throws JiBXException on any error (possible wrapping other exception)
*/
public String parseElementText(String ns, String tag) throws JiBXException {
parsePastStartTag(ns, tag);
return parseContentText(ns, tag);
}
/**
* Parse entire element, returning optional text content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag. Returns the default text if the element is not found.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @param dflt default text value
* @return content text from element
* @throws JiBXException on any error (possible wrapping other exception)
*/
public String parseElementText(String ns, String tag, String dflt)
throws JiBXException {
if (parseIfStartTag(ns, tag)) {
return parseContentText(ns, tag);
} else {
return dflt;
}
}
/**
* Get text value of attribute from current start tag.
* Throws an exception if the attribute value is not found in the start
* tag.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @return attribute value text
* @throws JiBXException if attribute not present
*/
public String attributeText(String ns, String name) throws JiBXException {
String value = getAttributeValue(ns, name);
if (value == null) {
throw new JiBXException("Missing required attribute " +
buildNameString(ns, name) + " " + buildPositionString());
} else {
return value;
}
}
/**
* Get text value of optional attribute from current start
* tag. If the attribute is not present the supplied default value is
* returned instead.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @param dflt value to be returned if attribute is not present
* @return attribute value text
*/
public String attributeText(String ns, String name, String dflt) {
String value = getAttributeValue(ns, name);
if (value == null) {
return dflt;
} else {
return value;
}
}
/**
* Find the object corresponding to an ID. This method just handles the
* lookup and checks the object type.
*
* @param id ID text
* @param index expected reference type index
* @return object corresponding to IDREF, or null if not
* yet defined
* @throws JiBXException on any error
*/
public Object findID(String id, int index) throws JiBXException {
Map map = m_idMaps[index];
if (map != null) {
Object obj = map.get(id);
if (obj == null || obj instanceof BackFillHolder) {
return null;
} else if (m_idClasses == null ||
m_idClasses[index].equals(obj.getClass().getName())) {
return obj;
} else {
throwStartTagException
("IDREF element content mapped to wrong type");
}
}
return null;
}
/**
* Find previously defined object corresponding to an ID. This does the
* lookup and checks that the referenced object has been defined.
*
* @param id ID text
* @param index expected reference type index
* @return object corresponding to IDREF
* @throws JiBXException on any error
*/
public Object findDefinedID(String id, int index) throws JiBXException {
Object obj = findID(id, index);
if (obj == null) {
throwStartTagException("ID " + id + " not defined");
}
return obj;
}
/**
* Parse entire element, returning object (if defined yet) corresponding
* to content interpreted as IDREF. Expects to find the element start tag,
* text content, and end tag, in that order, and returns with the parser
* positioned following the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag attribute name expected
* @param index expected reference type index
* @return object corresponding to IDREF, or null if not
* yet defined
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public Object parseElementForwardIDREF(String ns, String tag, int index)
throws JiBXException {
parsePastStartTag(ns, tag);
m_idref = parseContentText(ns, tag);
return findID(m_idref, index);
}
/**
* Get object (if defined yet) corresponding to IDREF attribute from
* current start tag.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @param index expected reference type index
* @return object corresponding to IDREF, or null if not
* yet defined
* @throws JiBXException if attribute not present, or ID mapped to a
* different type of object than expected
*/
public Object attributeForwardIDREF(String ns, String name, int index)
throws JiBXException {
m_idref = attributeText(ns, name);
return findID(m_idref, index);
}
/**
* Parse entire element, returning previously defined object corresponding
* to content interpreted as IDREF. Expects to find the element start tag,
* text content, and end tag, in that order, and returns with the parser
* positioned following the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag attribute name expected
* @param index expected reference type index
* @return object corresponding to IDREF
* @throws JiBXException if attribute not present, ID not defined, or
* mapped to a different type of object than expected
*/
public Object parseElementExistingIDREF(String ns, String tag, int index)
throws JiBXException {
parsePastStartTag(ns, tag);
m_idref = parseContentText(ns, tag);
return findDefinedID(m_idref, index);
}
/**
* Get previously defined object corresponding to IDREF attribute from
* current start tag.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @param index expected reference type index
* @return object corresponding to IDREF
* @throws JiBXException if attribute not present, ID not defined, or
* mapped to a different type of object than expected
*/
public Object attributeExistingIDREF(String ns, String name, int index)
throws JiBXException {
m_idref = attributeText(ns, name);
return findDefinedID(m_idref, index);
}
/**
* Get integer value of attribute from current start tag.
* Throws an exception if the attribute is not found in the start
* tag, or if it is not a valid integer value.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @return attribute integer value
* @throws JiBXException if attribute not present or not a valid integer
* value
*/
public int attributeInt(String ns, String name) throws JiBXException {
String text = attributeText(ns, name);
try {
return Utility.parseInt(text);
} catch (JiBXException ex) {
throw new JiBXParseException(ex.getMessage() + ' ' +
buildPositionString(), text, ns, name, ex.getRootCause());
}
}
/**
* Get integer value of optional attribute from current
* start tag. If the attribute is not present the supplied default value
* is returned instead.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @param dflt value to be returned if attribute is not present
* @return attribute integer value
* @throws JiBXException if attribute value is not a valid integer
*/
public int attributeInt(String ns, String name, int dflt)
throws JiBXException {
String value = getAttributeValue(ns, name);
if (value == null) {
return dflt;
} else {
try {
return Utility.parseInt(value);
} catch (JiBXException ex) {
throw new JiBXParseException(ex.getMessage() + ' ' +
buildPositionString(), value, ns, name, ex.getRootCause());
}
}
}
/**
* Parse entire element, returning integer value of content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @return content text from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public int parseElementInt(String ns, String tag) throws JiBXException {
parsePastStartTag(ns, tag);
return parseContentInt(ns, tag);
}
/**
* Parse entire optional element, returning integer value of content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag. Returns the default value if the element is missing or
* has no content.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @param dflt default value
* @return content text from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public int parseElementInt(String ns, String tag, int dflt)
throws JiBXException {
if (parseIfStartTag(ns, tag)) {
return parseContentInt(ns, tag);
} else {
return dflt;
}
}
/**
* Find required text value in enumeration. Looks up and returns the
* enumeration value corresponding to the target text.
*
* @param target text to be found in enumeration
* @param enums ordered array of texts included in enumeration
* @param vals array of values to be returned for corresponding text match
* positions (position returned directly if this is null)
* @return enumeration value for target text
* @throws JiBXException if target text not found in enumeration
*/
public int convertEnum(String target, String[] enums, int[] vals)
throws JiBXException {
if (target == null) {
throwStartTagException("Missing required enumeration value");
}
try {
return Utility.enumValue(target, enums, vals);
} catch (JiBXException ex) {
throw new JiBXConstrainedParseException(ex.getMessage() + ' ' +
buildPositionString(), target, enums);
}
}
/**
* Find optional text value in enumeration. Looks up and returns the
* enumeration value corresponding to the target text, or the default
* value if the text is null.
*
* @param target text to be found in enumeration (may be null)
* @param enums ordered array of texts included in enumeration
* @param vals array of values to be returned for corresponding text match
* positions (position returned directly if this is null)
* @param dflt default value returned if target text is null
* @return enumeration value for target text
* @throws JiBXException if target text not found in enumeration
*/
public int convertEnum(String target, String[] enums, int[] vals, int dflt)
throws JiBXException {
if (target == null) {
return dflt;
}
try {
return Utility.enumValue(target, enums, vals);
} catch (JiBXException ex) {
throw new JiBXConstrainedParseException(ex.getMessage() + ' ' +
buildPositionString(), target, enums);
}
}
/**
* Get enumeration attribute value from current start tag.
* Throws an exception if the attribute value is not found in the start
* tag or the text does not match a value defined in the enumeration table.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @param enums ordered array of texts included in enumeration
* @param vals array of values to be returned for corresponding text match
* positions (position returned directly if this is null)
* @return enumeration value for target text
* @throws JiBXException if attribute not present or value not found in
* enumeration list
*/
public int attributeEnumeration(String ns, String name, String[] enums,
int[] vals) throws JiBXException {
try {
return convertEnum(getAttributeValue(ns, name), enums, vals);
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
/**
* Get optional enumeration attribute value from current start tag.
* Throws an exception if the attribute value is present but does not match
* a value defined in the enumeration table.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @param enums ordered array of texts included in enumeration
* @param vals array of values to be returned for corresponding text match
* positions (position returned directly if this is null)
* @param dflt default value returned if attribute is not present
* @return enumeration value for target text
* @throws JiBXException if attribute not present or value not found in
* enumeration list
*/
public int attributeEnumeration(String ns, String name, String[] enums,
int[] vals, int dflt) throws JiBXException {
try {
return convertEnum(getAttributeValue(ns, name), enums, vals, dflt);
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
/**
* Parse past end of element, returning enumeration value of content.
* Assumes you've already parsed past the start tag of the element, so it
* just looks for text content followed by the end tag, and returns with the
* parser positioned after the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @param enums ordered array of texts included in enumeration
* @param vals array of values to be returned for corresponding text match
* positions (position returned directly if this is null)
* @return enumeration value for element text
* @throws JiBXException on any error (possible wrapping other exception)
*/
public int parseContentEnumeration(String ns, String tag, String[] enums,
int[] vals) throws JiBXException {
try {
return convertEnum(parseContentText(ns, tag), enums, vals);
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
}
/**
* Parse entire element, returning enumeration value of optional content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag. Returns the default value if no content is present.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @param enums ordered array of texts included in enumeration
* @param vals array of values to be returned for corresponding text match
* positions (position returned directly if this is null)
* @param dflt default value
* @return enumeration value for element text
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public int parseElementEnumeration(String ns, String tag, String[] enums,
int[] vals, int dflt) throws JiBXException {
if (parseIfStartTag(ns, tag)) {
String text = parseContentText(ns, tag);
try {
return convertEnum(text, enums, vals, dflt);
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
} else {
return dflt;
}
}
/**
* Convert byte value with exception wrapper. This internal method is used
* by all the byte unmarshalling calls. It adds position information to
* any exceptions that occur.
*
* @param text text for value to be converted
* @return converted byte value
* @throws JiBXException if not a valid byte value
*/
public byte convertByte(String text) throws JiBXException {
try {
return Utility.parseByte(text);
} catch (JiBXException ex) {
throw new JiBXParseException(ex.getMessage() + ' ' +
buildPositionString(), text, ex.getRootCause());
}
}
/**
* Get byte value of attribute from current start tag. Throws an exception
* if the attribute is not found in the start tag, or if it is not a valid
* integer value.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @return attribute byte value
* @throws JiBXException if attribute not present or not a valid byte value
*/
public byte attributeByte(String ns, String name) throws JiBXException {
try {
return convertByte(attributeText(ns, name));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
/**
* Get byte value of optional attribute from current start tag. If the
* attribute is not present the supplied default value is returned instead.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @param dflt value to be returned if attribute is not present
* @return attribute byte value
* @throws JiBXException if attribute value is not a valid byte
*/
public byte attributeByte(String ns, String name, byte dflt)
throws JiBXException {
String text = getAttributeValue(ns, name);
if (text == null) {
return dflt;
} else {
try {
return convertByte(text);
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
}
/**
* Parse past end of element, returning byte value of content. Assumes
* you've already parsed past the start tag of the element, so it just looks
* for text content followed by the end tag, and returns with the parser
* positioned after the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @return converted value from element text
* @throws JiBXException on any error (possible wrapping other exception)
*/
public byte parseContentByte(String ns, String tag) throws JiBXException {
try {
return convertByte(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
}
/**
* Parse entire element, returning byte value of content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @return content text from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public byte parseElementByte(String ns, String tag) throws JiBXException {
parsePastStartTag(ns, tag);
return parseContentByte(ns, tag);
}
/**
* Parse entire element, returning byte value of optional content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag. Returns the default value if no content is present.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @param dflt default value
* @return content text from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public byte parseElementByte(String ns, String tag, byte dflt)
throws JiBXException {
if (parseIfStartTag(ns, tag)) {
try {
return convertByte(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
} else {
return dflt;
}
}
/**
* Convert short value with exception wrapper. This internal method is used
* by all the short unmarshalling calls. It adds position information to
* any exceptions that occur.
*
* @param text text for value to be converted
* @return converted short value
* @throws JiBXException if not a valid short value
*/
public short convertShort(String text) throws JiBXException {
try {
return Utility.parseShort(text);
} catch (JiBXException ex) {
throw new JiBXParseException(ex.getMessage() + ' ' +
buildPositionString(), text, ex.getRootCause());
}
}
/**
* Get short value of attribute from current start tag. Throws an exception
* if the attribute is not found in the start tag, or if it is not a valid
* integer value.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @return attribute short value
* @throws JiBXException if attribute not present or not a valid short value
*/
public short attributeShort(String ns, String name) throws JiBXException {
try {
return convertShort(attributeText(ns, name));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
/**
* Get short value of optional attribute from current start tag. If the
* attribute is not present the supplied default value is returned instead.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @param dflt value to be returned if attribute is not present
* @return attribute short value
* @throws JiBXException if attribute value is not a valid short
*/
public short attributeShort(String ns, String name, short dflt)
throws JiBXException {
String text = getAttributeValue(ns, name);
if (text == null) {
return dflt;
} else {
try {
return convertShort(text);
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
}
/**
* Parse past end of element, returning short value of content. Assumes
* you've already parsed past the start tag of the element, so it just looks
* for text content followed by the end tag, and returns with the parser
* positioned after the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @return converted value from element text
* @throws JiBXException on any error (possible wrapping other exception)
*/
public short parseContentShort(String ns, String tag) throws JiBXException {
try {
return convertShort(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
}
/**
* Parse entire element, returning short value of content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @return content text from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public short parseElementShort(String ns, String tag) throws JiBXException {
parsePastStartTag(ns, tag);
try {
return parseContentShort(ns, tag);
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
}
/**
* Parse entire element, returning short value of optional content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag. Returns the default value if no content is present.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @param dflt default value
* @return content text from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public short parseElementShort(String ns, String tag, short dflt)
throws JiBXException {
if (parseIfStartTag(ns, tag)) {
try {
return convertShort(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
} else {
return dflt;
}
}
/**
* Convert char value with exception wrapper. This internal method is used
* by all the char unmarshalling calls. It adds position information to
* any exceptions that occur.
*
* @param text text for value to be converted
* @return converted char value
* @throws JiBXException if not a valid char value
*/
public char convertChar(String text) throws JiBXException {
try {
return Utility.parseChar(text);
} catch (JiBXException ex) {
throw new JiBXParseException(ex.getMessage() + ' ' +
buildPositionString(), text, ex.getRootCause());
}
}
/**
* Get char value of attribute from current start tag. Throws an exception
* if the attribute is not found in the start tag, or if it is not a valid
* integer value.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @return attribute char value
* @throws JiBXException if attribute not present or not a valid char value
*/
public char attributeChar(String ns, String name) throws JiBXException {
try {
return convertChar(attributeText(ns, name));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
/**
* Get char value of optional attribute from current start tag. If the
* attribute is not present the supplied default value is returned instead.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @param dflt value to be returned if attribute is not present
* @return attribute char value
* @throws JiBXException if attribute value is not a valid char
*/
public char attributeChar(String ns, String name, char dflt)
throws JiBXException {
String text = getAttributeValue(ns, name);
if (text == null) {
return dflt;
} else {
try {
return convertChar(text);
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
}
/**
* Parse past end of element, returning char value of content. Assumes
* you've already parsed past the start tag of the element, so it just looks
* for text content followed by the end tag, and returns with the parser
* positioned after the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @return converted value from element text
* @throws JiBXException on any error (possible wrapping other exception)
*/
public char parseContentChar(String ns, String tag) throws JiBXException {
try {
return convertChar(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
}
/**
* Parse entire element, returning char value of content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @return content text from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public char parseElementChar(String ns, String tag) throws JiBXException {
parsePastStartTag(ns, tag);
try {
return parseContentChar(ns, tag);
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
}
/**
* Parse entire element, returning char value of optional content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag. Returns the default value if the element is not present.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @param dflt default value
* @return content text from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public char parseElementChar(String ns, String tag, char dflt)
throws JiBXException {
if (parseIfStartTag(ns, tag)) {
try {
return convertChar(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
} else {
return dflt;
}
}
/**
* Convert long value with exception wrapper. This internal method is used
* by all the long unmarshalling calls. It adds position information to
* any exceptions that occur.
*
* @param text text for value to be converted
* @return converted long value
* @throws JiBXException if not a valid long value
*/
public long convertLong(String text) throws JiBXException {
try {
return Utility.parseLong(text);
} catch (JiBXException ex) {
throw new JiBXParseException(ex.getMessage() + ' ' +
buildPositionString(), text, ex.getRootCause());
}
}
/**
* Get long value of attribute from current start tag. Throws an exception
* if the attribute is not found in the start tag, or if it is not a valid
* integer value.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @return attribute long value
* @throws JiBXException if attribute not present or not a valid long value
*/
public long attributeLong(String ns, String name) throws JiBXException {
try {
return convertLong(attributeText(ns, name));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
/**
* Get long value of optional attribute from current start tag. If the
* attribute is not present the supplied default value is returned instead.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @param dflt value to be returned if attribute is not present
* @return attribute long value
* @throws JiBXException if attribute value is not a valid long
*/
public long attributeLong(String ns, String name, long dflt)
throws JiBXException {
String text = getAttributeValue(ns, name);
if (text == null) {
return dflt;
} else {
try {
return convertLong(text);
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
}
/**
* Parse past end of element, returning long value of content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @return converted value from element text
* @throws JiBXException on any error (possible wrapping other exception)
*/
public long parseElementLong(String ns, String tag) throws JiBXException {
parsePastStartTag(ns, tag);
try {
return convertLong(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
}
/**
* Parse entire element, returning long value of optional content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag. Returns the default value if the element is not present.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @param dflt default value
* @return content text from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public long parseElementLong(String ns, String tag, long dflt)
throws JiBXException {
if (parseIfStartTag(ns, tag)) {
try {
return convertLong(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
} else {
return dflt;
}
}
/**
* Convert boolean value. This internal method is used by all the boolean
* unmarshalling calls. It accepts "true" or "1" as equivalent, and "false"
* or "0" as equivalent, and throws exceptions for anything else.
*
* @param text text for value to be converted
* @return converted boolean value
* @throws JiBXException if not a valid boolean value
*/
public boolean convertBoolean(String text) throws JiBXException {
if ("true".equalsIgnoreCase(text) || "1".equals(text)) {
return true;
} else if ("false".equalsIgnoreCase(text) || "0".equals(text)) {
return false;
}
throw new JiBXParseException("Invalid boolean value " +
buildPositionString(), text);
}
/**
* Get boolean value of attribute from current start tag. Throws an
* exception if the attribute is not found in the start tag, or if it is
* not a valid integer value.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @return attribute boolean value
* @throws JiBXException if attribute not present or not a valid boolean
* value
*/
public boolean attributeBoolean(String ns, String name)
throws JiBXException {
try {
return convertBoolean(attributeText(ns, name));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
/**
* Get boolean value of optional attribute from current start tag. If the
* attribute is not present the supplied default value is returned instead.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @param dflt value to be returned if attribute is not present
* @return attribute boolean value
* @throws JiBXException if attribute value is not a valid boolean
*/
public boolean attributeBoolean(String ns, String name, boolean dflt)
throws JiBXException {
String text = getAttributeValue(ns, name);
if (text == null) {
return dflt;
} else {
try {
return convertBoolean(text);
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
}
/**
* Parse entire element, returning boolean value of content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @return converted value from element text
* @throws JiBXException on any error (possible wrapping other exception)
*/
public boolean parseElementBoolean(String ns, String tag)
throws JiBXException {
parsePastStartTag(ns, tag);
try {
return convertBoolean(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
}
/**
* Parse entire element, returning boolean value of optional content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag. Returns the default value if the element is not present.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @param dflt default value
* @return content text from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public boolean parseElementBoolean(String ns, String tag, boolean dflt)
throws JiBXException {
if (parseIfStartTag(ns, tag)) {
try {
return convertBoolean(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
} else {
return dflt;
}
}
/**
* Convert float value with exception wrapper. This internal method is used
* by all the float unmarshalling calls. It adds position information to
* any exceptions that occur.
*
* @param text text for value to be converted
* @return converted float value
* @throws JiBXException if not a valid float value
*/
public float convertFloat(String text) throws JiBXException {
try {
return Utility.parseFloat(text);
} catch (JiBXException ex) {
throw new JiBXParseException(ex.getMessage() + ' ' +
buildPositionString(), text, ex.getRootCause());
}
}
/**
* Get float value of attribute from current start tag. Throws an exception
* if the attribute is not found in the start tag, or if it is not a valid
* integer value.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @return attribute float value
* @throws JiBXException if attribute not present or not a valid float value
*/
public float attributeFloat(String ns, String name) throws JiBXException {
try {
return convertFloat(attributeText(ns, name));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
/**
* Get float value of optional attribute from current start tag. If the
* attribute is not present the supplied default value is returned instead.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @param dflt value to be returned if attribute is not present
* @return attribute float value
* @throws JiBXException if attribute value is not a valid float
*/
public float attributeFloat(String ns, String name, float dflt)
throws JiBXException {
String text = getAttributeValue(ns, name);
if (text == null) {
return dflt;
} else {
try {
return convertFloat(text);
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
}
/**
* Parse past end of element, returning float value of content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @return converted value from element text
* @throws JiBXException on any error (possible wrapping other exception)
*/
public float parseElementFloat(String ns, String tag) throws JiBXException {
parsePastStartTag(ns, tag);
try {
return convertFloat(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
}
/**
* Parse entire element, returning float value of optional content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag. Returns the default value if the element is not present.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @param dflt default value
* @return content text from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public float parseElementFloat(String ns, String tag, float dflt)
throws JiBXException {
if (parseIfStartTag(ns, tag)) {
try {
return convertFloat(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
} else {
return dflt;
}
}
/**
* Convert double value with exception wrapper. This internal method is used
* by all the double unmarshalling calls. It adds position information to
* any exceptions that occur.
*
* @param text text for value to be converted
* @return converted double value
* @throws JiBXException if not a valid double value
*/
public double convertDouble(String text) throws JiBXException {
try {
return Utility.parseDouble(text);
} catch (JiBXException ex) {
throw new JiBXParseException(ex.getMessage() + ' ' +
buildPositionString(), text, ex.getRootCause());
}
}
/**
* Get double value of attribute from current start tag. Throws an exception
* if the attribute is not found in the start tag, or if it is not a valid
* integer value.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @return attribute double value
* @throws JiBXException if attribute not present or not a valid double
* value
*/
public double attributeDouble(String ns, String name) throws JiBXException {
try {
return convertDouble(attributeText(ns, name));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
/**
* Get double value of optional attribute from current start tag. If the
* attribute is not present the supplied default value is returned instead.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @param dflt value to be returned if attribute is not present
* @return attribute double value
* @throws JiBXException if attribute value is not a valid double
*/
public double attributeDouble(String ns, String name, double dflt)
throws JiBXException {
String text = getAttributeValue(ns, name);
if (text == null) {
return dflt;
} else {
try {
return convertDouble(text);
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
}
/**
* Parse past end of element, returning double value of content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @return converted value from element text
* @throws JiBXException on any error (possible wrapping other exception)
*/
public double parseElementDouble(String ns, String tag)
throws JiBXException {
parsePastStartTag(ns, tag);
try {
return convertDouble(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
}
/**
* Parse entire element, returning double value of optional content.
* Expects to find the element start tag, text content, and end tag,
* in that order, and returns with the parser positioned following
* the end tag. Returns the default value if the element is not present.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @param dflt default value
* @return content text from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public double parseElementDouble(String ns, String tag, double dflt)
throws JiBXException {
if (parseIfStartTag(ns, tag)) {
try {
return convertDouble(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
} else {
return dflt;
}
}
/**
* Convert java.util.Date value with exception wrapper. This
* internal method is used by all the Date unmarshalling calls. It adds
* position information to any exceptions that occur.
*
* @param text text for value to be converted
* @return converted Date value
* @throws JiBXException if not a valid Date value
*/
public Date convertDate(String text) throws JiBXException {
try {
return new Date(Utility.parseDateTime(text));
} catch (JiBXException ex) {
throw new JiBXParseException(ex.getMessage() + ' ' +
buildPositionString(), text, ex.getRootCause());
}
}
/**
* Get java.util.Date value of attribute from current start
* tag. Throws an exception if the attribute is not found in the start tag,
* or if it is not a valid integer value.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @return attribute Date value
* @throws JiBXException if attribute not present or not a valid Date
* value
*/
public Date attributeDate(String ns, String name) throws JiBXException {
try {
return convertDate(attributeText(ns, name));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
/**
* Get java.util.Date value of optional attribute from current
* start tag. If the attribute is not present the supplied default value is
* returned instead.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @param dflt value to be returned if attribute is not present
* @return attribute Date value
* @throws JiBXException if attribute value is not a valid Date
*/
public Date attributeDate(String ns, String name, Date dflt)
throws JiBXException {
String text = getAttributeValue(ns, name);
if (text == null) {
return dflt;
} else {
try {
return convertDate(text);
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(name);
throw e;
}
}
}
/**
* Parse past end of element, returning java.util.Date value
* of content. Expects to find the element start tag, text content,
* and end tag, in that order, and returns with the parser positioned
* following the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @return converted value from element text
* @throws JiBXException on any error (possible wrapping other exception)
*/
public Date parseElementDate(String ns, String tag) throws JiBXException {
parsePastStartTag(ns, tag);
try {
return convertDate(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
}
/**
* Parse entire element, returning java.util.Date value of
* optional content. Expects to find the element start tag, text content,
* and end tag, in that order, and returns with the parser positioned
* following the end tag. Returns the default value if the element is not
* present.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @param dflt default value
* @return content text from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public Date parseElementDate(String ns, String tag, Date dflt)
throws JiBXException {
if (parseIfStartTag(ns, tag)) {
try {
return convertDate(parseContentText(ns, tag));
} catch (JiBXParseException e) {
e.setNamespace(ns);
e.setTagName(tag);
throw e;
}
} else {
return dflt;
}
}
/**
* Register back fill item for undefined ID value. This adds a holder to
* the mapping table if not already present, then adds the back fill item
* to the holder.
*
* @param id target undefined ID value
* @param index target reference type index
* @param fill back fill item
* @throws JiBXException if attribute not present, or ID already defined
*/
public void registerBackFill(String id, int index, BackFillReference fill)
throws JiBXException {
Map map = m_idMaps[index];
if (map == null) {
m_idMaps[index] = map = new HashMap();
}
Object obj = map.get(id);
if (obj == null) {
String xclass = (m_idClasses == null) ? null : m_idClasses[index];
BackFillHolder holder = new BackFillHolder(xclass);
map.put(id, holder);
holder.addBackFill(fill);
} else if (obj instanceof BackFillHolder) {
((BackFillHolder)obj).addBackFill(fill);
} else {
throw new JiBXException
("Internal operation error (back fill error) " +
buildPositionString());
}
}
/**
* Register back fill item for last parsed ID value. This adds a holder to
* the mapping table if not already present, then adds the back fill item
* to the holder. This form of call always applies to the last IDREF value
* parsed (from either an element or an attribute).
*
* @param index target reference type index
* @param fill back fill item
* @throws JiBXException if attribute not present, or ID already defined
*/
public void registerBackFill(int index, BackFillReference fill)
throws JiBXException {
registerBackFill(m_idref, index, fill);
}
/**
* Define object for ID. Adds the owning object to a map with the ID
* value as key. Throws an exception if the object class does not match
* that expected from forward references, or if another object has
* previously been registered with the same ID.
*
* @param id text ID value
* @param index ID class index number
* @param obj object corresponding to element
* @throws JiBXException if duplicate ID or wrong class
*/
public void defineID(String id, int index, Object obj)
throws JiBXException {
Map map = m_idMaps[index];
if (map == null) {
m_idMaps[index] = map = new HashMap();
}
Object prior = map.put(id, obj);
if (prior instanceof BackFillHolder) {
BackFillHolder holder = (BackFillHolder)prior;
String xclass = holder.getExpectedClass();
if (xclass == null || xclass.equals(obj.getClass().getName())) {
holder.defineValue(obj);
} else {
throw new JiBXException("ID object has wrong type " +
buildPositionString());
}
} else if (prior != null) {
throw new JiBXException("Duplicate ID definition " +
buildPositionString());
}
}
/**
* Map unmarshalling for element. Adds the entry for a particular class
* index to the unmarshalling map.
*
* @param index class index for unmarshalling definition to be added
*/
protected void mapUnmarshalling(int index) {
Integer add = new Integer(index);
Object value = m_transientUnmarshalMap.get(m_names[index]);
if (value instanceof Integer) {
ArrayList list = new ArrayList();
list.add(value);
list.add(add);
m_transientUnmarshalMap.put(m_names[index], list);
} else if (value instanceof ArrayList) {
ArrayList list = (ArrayList)value;
list.add(add);
} else {
m_transientUnmarshalMap.put(m_names[index], add);
}
}
/**
* Define unmarshalling for element. Enables the unmarshalling definition
* linking an element name (including namespace) with a handler.
*
* @param mapname mapping name associated with unmarshaller
* @param ns namespace for element (may be null
* or the empty string for the empty namespace)
* @param name name for element
* @param cname unmarshaller class name
* @throws JiBXException if unknown mapping name
*/
public void addUnmarshalling(String mapname, String ns, String name,
String cname) throws JiBXException {
int index = m_classIndexMap.get(mapname);
if (index < 0) {
throw new JiBXException("No unmarshal mapping defined for class " + mapname);
}
m_namespaces[index] = ns;
m_names[index] = name;
m_transientUnmarshallerClasses[index-m_transientBase] = cname;
if (m_transientUnmarshalMap != null && name != null) {
mapUnmarshalling(index);
}
}
/**
* Undefine unmarshalling for element. Disables the unmarshalling
* definition for a particular mapping name.
*
* @param mapname mapping name associated with unmarshaller
* @throws JiBXException if unknown mapping name
*/
public void removeUnmarshalling(String mapname) throws JiBXException {
int index = m_classIndexMap.get(mapname);
if (index < 0) {
throw new JiBXException("No unmarshal mapping defined for class " + mapname);
}
if (m_transientUnmarshalMap != null && m_names[index] != null) {
Object value = m_transientUnmarshalMap.get(m_names[index]);
if (value instanceof Integer) {
m_transientUnmarshalMap.remove(m_names[index]);
} else if (value instanceof ArrayList) {
ArrayList list = (ArrayList)value;
for (int i = 0; i < list.size(); i++) {
Integer item = (Integer)list.get(i);
if (item.intValue() == index) {
list.remove(i);
}
}
}
}
m_namespaces[index] = null;
m_names[index] = null;
m_unmarshallers[index] = null;
m_transientUnmarshallerClasses[index-m_transientBase] = null;
}
/**
* Find the unmarshaller for a particular class index in the current
* context.
*
* @param index class index for unmarshalling definition
* @return unmarshalling handler for class
* @throws JiBXException if unable to create unmarshaller
*/
private IUnmarshaller getUnmarshaller(int index) throws JiBXException {
if (m_unmarshallers[index] == null) {
// load the unmarshaller class and create an instance
Class clas;
String mname = m_factory.getUnmarshallerClasses()[index];
if (mname != null) {
// get global unmarshaller class through factory
clas = m_factory.getUnmarshallerClass(index);
} else {
// load transient unmarshaller class directly
mname = m_transientUnmarshallerClasses[index-m_transientBase];
if (mname == null) {
throw new JiBXException("No unmarshaller defined for class " + m_factory.getMappedClasses()[index]);
}
clas = m_factory.loadClass(mname);
}
try {
// make sure we have a class
if (clas == null) {
throw new JiBXException("Unable to load unmarshaller class " + mname);
}
// create and cache an instance of the class
IUnmarshaller m = (IUnmarshaller)clas.newInstance();
m_unmarshallers[index] = m;
} catch (JiBXException e) {
throw e;
} catch (Exception e) {
throw new JiBXException("Unable to create unmarshaller of class " + mname + ":", e);
}
}
return m_unmarshallers[index];
}
/**
* Find the unmarshaller for a particular class in the current context.
*
* @param mapname unmarshaller mapping name (generally the class name to be
* handled, or abstract mapping type name)
* @return unmarshalling handler for class
* @throws JiBXException if unable to create unmarshaller
*/
public IUnmarshaller getUnmarshaller(String mapname) throws JiBXException {
int index = m_classIndexMap.get(mapname);
if (index >= 0) {
return getUnmarshaller(index);
} else {
throw new JiBXException("No unmarshal mapping defined for class " + mapname);
}
}
/**
* Find the unmarshaller for a particular element name (including
* namespace) in the current context.
*
* @param ns namespace for element (may be null
* or the empty string for the empty namespace)
* @param name name for element
* @return unmarshalling handler for element, or null if none
* found
* @throws JiBXException if unable to create unmarshaller
*/
public IUnmarshaller getUnmarshaller(String ns, String name)
throws JiBXException {
// check if unmarshal name map needs to be initialized
if (m_unmarshalMap == null) {
// get cached map for globals and create map for transients
m_unmarshalMap = m_factory.getUnmarshalMap();
m_transientUnmarshalMap = new HashMap();
for (int i = 0; i < m_names.length; i++) {
if (m_transientUnmarshallerClasses[i-m_transientBase] != null &&
m_names[i] != null) {
mapUnmarshalling(i);
}
}
}
// first check for name match in transient unmarshal map
Object value = m_transientUnmarshalMap.get(name);
if (value != null) {
int index = -1;
if (value instanceof Integer) {
int i = ((Integer)value).intValue();
String mns = m_namespaces[i];
if (ns == mns || (ns == null && mns.length() == 0) ||
(mns == null && ns.length() == 0) ||
(ns != null && ns.equals(mns))) {
index = i;
}
} else if (value instanceof List) {
List list = (List)value;
for (int i = 0; i < list.size(); i++) {
int j = ((Integer)list.get(i)).intValue();
String mns = m_namespaces[j];
if (ns == mns || (ns == null && mns.length() == 0) ||
(mns == null && ns.length() == 0) ||
(ns != null && ns.equals(mns))) {
index = j;
break;
}
}
}
if (index >= 0) {
return getUnmarshaller(index);
}
}
// next check for match in global unmarshal map
value = m_unmarshalMap.get(name);
if (value != null) {
int index = -1;
if (value instanceof Integer) {
int i = ((Integer)value).intValue();
String mns = m_namespaces[i];
if (ns == mns || (ns == null && mns.length() == 0) ||
(mns == null && ns.length() == 0) ||
(ns != null && ns.equals(mns))) {
index = i;
}
} else if (value instanceof int[]) {
int[] ints = (int[])value;
for (int i = 0; i < ints.length; i++) {
String mns = m_namespaces[ints[i]];
if (ns == mns || (ns == null && mns.length() == 0) ||
(mns == null && ns.length() == 0) ||
(ns != null && ns.equals(mns))) {
index = ints[i];
break;
}
}
}
if (index >= 0) {
return getUnmarshaller(index);
}
}
return null;
}
/**
* Unmarshal optional element. If not currently positioned at a start or
* end tag this first advances the parse to the next start or end tag.
*
* @return unmarshalled object from element, or null if end tag
* rather than start tag seen
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public Object unmarshalOptionalElement() throws JiBXException {
int type = toTag();
if (type == IXMLReader.START_TAG) {
IUnmarshaller unmarshal =
getUnmarshaller(m_reader.getNamespace(), m_reader.getName());
if (unmarshal != null) {
return unmarshal.unmarshal(null, this);
}
}
return null;
}
/**
* Unmarshal required element of specified type. If not currently positioned
* at a start or end tag this first advances the parse to the next start or
* end tag. The returned object will always be assignable to the specified
* type.
*
* @param clas expected class of unmarshalled object
* @return unmarshalled object from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public Object unmarshalElement(Class clas) throws JiBXException {
String name = toStart();
IUnmarshaller unmarshal =
getUnmarshaller(m_reader.getNamespace(), name);
if (unmarshal == null) {
throw new JiBXException("No unmarshaller for element " +
currentNameString() + " " + buildPositionString());
} else {
Object obj = unmarshal.unmarshal(null, this);
if (!clas.isInstance(obj)) {
throw new JiBXException("Element " + name +
" not compatible with expected type " + clas.getName() +
" " + buildPositionString());
}
return obj;
}
}
/**
* Unmarshal required element. If not currently positioned at a start or
* end tag this first advances the parse to the next start or end tag.
*
* @return unmarshalled object from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
public Object unmarshalElement() throws JiBXException {
String name = toStart();
IUnmarshaller unmarshal =
getUnmarshaller(m_reader.getNamespace(), name);
if (unmarshal == null) {
throw new JiBXException("No unmarshaller for element " +
currentNameString() + " " + buildPositionString());
} else {
return unmarshal.unmarshal(null, this);
}
}
/**
* Parse past element, ignoring all content. This may be used while
* positioned either before or on the element start tag. It checks if
* currently positioned at the element start tag, and if so advances to the
* next parse event. Then looks for the next end tag, ignoring character
* data and skipping child elements. Leaves the parse positioned following
* the end tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param tag element name expected
* @throws JiBXException on any error (possible wrapping other exception)
*/
public void parsePastElement(String ns, String tag) throws JiBXException {
parsePastStartTag(ns, tag);
int depth = 0;
while (true) {
switch (m_reader.getEventType()) {
case IXMLReader.END_TAG:
if (depth == 0) {
if (m_reader.getName().equals(tag) &&
verifyNamespace(ns)) {
m_reader.nextToken();
return;
} else {
throwEndTagNameError(ns, tag);
}
} else {
depth--;
}
break;
case IXMLReader.START_TAG:
depth++;
break;
default:
break;
}
m_reader.nextToken();
}
}
/**
* Returns current element name.
*
* @return local name part of name, or null if not at a start
* or end tag
* @throws JiBXException if error from parser
*/
public String getElementName() throws JiBXException {
int type = m_reader.getEventType();
if (type == IXMLReader.START_TAG ||
type == IXMLReader.END_TAG) {
return m_reader.getName();
} else {
return null;
}
}
/**
* Returns current element namespace URI.
*
* @return namespace URI of name, or null if not at a start
* or end tag
* @throws JiBXException if error from parser
*/
public String getElementNamespace() throws JiBXException {
int type = m_reader.getEventType();
if (type == IXMLReader.START_TAG ||
type == IXMLReader.END_TAG) {
return m_reader.getNamespace();
} else {
return null;
}
}
/**
* Throw exception with start tag and position information.
*
* @param msg exception message text
* @exception JiBXException always thrown
*/
public void throwStartTagException(String msg) throws JiBXException {
throw new JiBXException(msg + " at tag " + currentNameString() +
buildPositionString());
}
/**
* Throw exception with start tag, position information, and nested
* exception.
*
* @param msg exception message text
* @param ex nested exception
* @exception JiBXException always thrown
*/
public void throwStartTagException(String msg, Exception ex)
throws JiBXException {
throw new JiBXException(msg + " at tag " + currentNameString() +
buildPositionString(), ex);
}
/**
* Throw exception with position information.
*
* @param msg exception message text
* @exception JiBXException always thrown
*/
public void throwException(String msg) throws JiBXException {
throw new JiBXException(msg + " " + buildPositionString());
}
/**
* Throw exception with position information and nested exception.
*
* @param msg exception message text
* @param ex nested exception
* @exception JiBXException always thrown
*/
public void throwException(String msg, Exception ex) throws JiBXException {
throw new JiBXException(msg + " " + buildPositionString(), ex);
}
/**
* Unmarshal document from stream to object. The effect of this is the same
* as if {@link #setDocument} were called, followed by {@link
* #unmarshalElement}
*
* @param ins stream supplying document data
* @param enc document input encoding, or null if to be
* determined by parser
* @return unmarshalled object
* @throws JiBXException if error creating parser
*/
public Object unmarshalDocument(InputStream ins, String enc)
throws JiBXException {
setDocument(ins, enc);
return unmarshalElement();
}
/**
* Unmarshal document from reader to object. The effect of this is the same
* as if {@link #setDocument} were called, followed by {@link
* #unmarshalElement}
*
* @param rdr reader supplying document data
* @return unmarshalled object
* @throws JiBXException if error creating parser
*/
public Object unmarshalDocument(Reader rdr) throws JiBXException {
setDocument(rdr);
return unmarshalElement();
}
/**
* Unmarshal named document from stream to object. The effect of this is the
* same as if {@link #setDocument} were called, followed by {@link
* #unmarshalElement}
*
* @param ins stream supplying document data
* @param name document name
* @param enc document input encoding, or null if to be
* determined by parser
* @return unmarshalled object
* @throws JiBXException if error creating parser
*/
public Object unmarshalDocument(InputStream ins, String name, String enc)
throws JiBXException {
setDocument(ins, name, enc);
return unmarshalElement();
}
/**
* Unmarshal named document from reader to object. The effect of this is the
* same as if {@link #setDocument} were called, followed by {@link
* #unmarshalElement}
*
* @param rdr reader supplying document data
* @param name document name
* @return unmarshalled object
* @throws JiBXException if error creating parser
*/
public Object unmarshalDocument(Reader rdr, String name)
throws JiBXException {
setDocument(rdr, name);
return unmarshalElement();
}
/**
* Return the binding factory used to create this unmarshaller.
*
* @return binding factory
*/
public IBindingFactory getFactory() {
return m_factory;
}
/**
* Return the supplied document name.
*
* @return supplied document name (null if none)
*/
public String getDocumentName() {
return m_reader.getDocumentName();
}
/**
* Return the input encoding, if known. This is only valid after parsing of
* a document has been started.
*
* @return input encoding (null if unknown)
*/
public String getInputEncoding() {
return m_reader.getInputEncoding();
}
/**
* Set a user context object. This context object is not used directly by
* JiBX, but can be accessed by all types of user extension methods. The
* context object is automatically cleared by the {@link #reset()} method,
* so to make use of this you need to first call the appropriate version of
* the setDocument() method, then this method, and finally the
* {@link #unmarshalElement} method.
*
* @param obj user context object, or null if clearing existing
* context object
* @see #getUserContext()
*/
public void setUserContext(Object obj) {
m_userContext = obj;
}
/**
* Get the user context object.
*
* @return user context object, or null if no context object
* set
* @see #setUserContext(Object)
*/
public Object getUserContext() {
return m_userContext;
}
/**
* Push created object to unmarshalling stack. This must be called before
* beginning the unmarshalling of the object. It is only called for objects
* with structure, not for those converted directly to and from text.
*
* @param obj object being unmarshalled
*/
public void pushObject(Object obj) {
int depth = m_stackDepth;
if (depth >= m_objectStack.length) {
Object[] stack = new Object[depth*2];
System.arraycopy(m_objectStack, 0, stack, 0, depth);
m_objectStack = stack;
}
m_objectStack[depth] = obj;
m_stackDepth++;
}
/**
* Set position tracking information for object, if supported.
*
* @param obj object being tracked
*/
public void trackObject(Object obj) {
if (obj instanceof ITrackSourceImpl) {
((ITrackSourceImpl)obj).jibx_setSource(m_reader.getDocumentName(),
m_reader.getLineNumber(), m_reader.getColumnNumber());
}
}
/**
* Push created object to unmarshalling stack with position tracking. If the
* object supports setting source location information, the location is also
* set by this method.
*
* @param obj object being unmarshalled
*/
public void pushTrackedObject(Object obj) {
pushObject(obj);
trackObject(obj);
}
/**
* Pop unmarshalled object from stack.
*
* @throws JiBXException if no object on stack
*/
public void popObject() throws JiBXException {
if (m_stackDepth > 0) {
--m_stackDepth;
} else {
throw new JiBXException("No object on stack");
}
}
/**
* Get current unmarshalling object stack depth. This allows tracking
* nested calls to unmarshal one object while in the process of
* unmarshalling another object. The bottom item on the stack is always the
* root object being unmarshalled.
*
* @return number of objects in unmarshalling stack
*/
public int getStackDepth() {
return m_stackDepth;
}
/**
* Get object from unmarshalling stack. This stack allows tracking nested
* calls to unmarshal one object while in the process of unmarshalling
* another object. The bottom item on the stack is always the root object
* being unmarshalled.
*
* @param depth object depth in stack to be retrieved (must be in the range
* of zero to the current depth minus one).
* @return object from unmarshalling stack
*/
public Object getStackObject(int depth) {
if (depth >= 0 && depth < m_stackDepth) {
return m_objectStack[m_stackDepth-depth-1];
} else {
throw new ArrayIndexOutOfBoundsException("Depth " + depth +
" is out of range");
}
}
/**
* Get top object on unmarshalling stack. This is safe to call even when no
* objects are on the stack.
*
* @return object from unmarshalling stack, or null if none
*/
public Object getStackTop() {
if (m_stackDepth > 0) {
return m_objectStack[m_stackDepth-1];
} else {
return null;
}
}
/**
* Get count of active namespaces.
*
* @return number of active namespaces in stack
*/
public int getActiveNamespaceCount() {
try {
return m_reader.getNamespaceCount(m_reader.getNestingDepth());
} catch (IllegalArgumentException e) {
throw new IllegalStateException("Internal error: " +
e.getMessage());
}
}
/**
* Get URI for an active namespace.
*
* @param index index number of namespace to be returned
* @return URI for namespace at position
* @throws IllegalArgumentException if invalid index
*/
public String getActiveNamespaceUri(int index) {
return m_reader.getNamespaceUri(index);
}
/**
* Get prefix for an active namespace.
*
* @param index stack position of namespace to be returned
* @return prefix for namespace at position
* @throws IllegalArgumentException if invalid index
*/
public String getActiveNamespacePrefix(int index) {
return m_reader.getNamespacePrefix(index);
}
/**
* Skip past current element.
*
* @exception JiBXException on any error (possibly wrapping other exception)
*/
public void skipElement() throws JiBXException {
// check positioned at start tag
if (!isEnd()) {
// skip past the start tag
next();
// loop until end tag reached
int depth = 1;
while (depth > 0) {
if (isEnd()) {
depth--;
} else {
depth++;
}
next();
}
}
}
/**
* Advance to next major parse event. This wraps the base parser call in
* order to catch and handle exceptions, and to preserve a reasonable level
* of parser independence.
*
* @return event type for next major parse event (START_TAG, TEXT, END_TAG,
* or END_DOCUMENT)
* @exception JiBXException on any error (possibly wrapping other exception)
*/
public int next() throws JiBXException {
return m_reader.next();
}
/**
* Advance to next parse event. This wraps the base parser call in order to
* catch and handle exceptions, and to preserve a reasonable level of parser
* independence.
*
* @return event type for next parse event
* @exception JiBXException on any error (possibly wrapping other exception)
*/
public int nextToken() throws JiBXException {
return m_reader.nextToken();
}
/**
* Get the current parse event type. This wraps the base parser call in
* order to catch and handle exceptions, and to preserve a reasonable level
* of parser independence.
*
* @return event type for current parse event
* @exception JiBXException on any error (possibly wrapping other exception)
*/
public int currentEvent() throws JiBXException {
return m_reader.getEventType();
}
/**
* Get name associated with current parse event.
*
* @return name text for name associated with event (START_ELEMENT,
* END_ELEMENT, or ENTITY_REF only)
* @throws IllegalStateException if not at a start or end tag (optional)
*/
public String getName() {
return m_reader.getName();
}
/**
* Get namespace associated with current parse event.
*
* @return URI for namespace associated with event (START_ELEMENT or
* END_ELEMENT only), empty string if none
* @throws IllegalStateException if not at a start or end tag (optional)
*/
public String getNamespace() {
return m_reader.getNamespace();
}
/**
* Get namespace prefix associated with current parse event.
*
* @return prefix for namespace associated with event (START_ELEMENT or
* END_ELEMENT only), null if none
* @throws IllegalStateException if not at a start or end tag (optional)
*/
public String getPrefix() {
return m_reader.getPrefix();
}
/**
* Get number of attributes for current START_ELEMENT event. The results are
* undefined if called when not at a START_ELEMENT event.
*
* @return number of attributes, or -1 if not at START_ELEMENT
* @throws IllegalStateException if not at a start tag (optional)
*/
public int getAttributeCount() {
return m_reader.getAttributeCount();
}
/**
* Get attribute name for current START_ELEMENT event. The results are
* undefined if called when not at a START_ELEMENT event.
*
* @param index index number of attribute to be returned
* @return name of attribute at position
* @throws IllegalStateException if not at a start tag or invalid index
*/
public String getAttributeName(int index) {
return m_reader.getAttributeName(index);
}
/**
* Get attribute namespace for current START_ELEMENT event. The results are
* undefined if called when not at a START_ELEMENT event.
*
* @param index index number of attribute to be returned
* @return namespace URI of attribute at position, empty string if none
* @throws IllegalStateException if not at a start tag or invalid index
*/
public String getAttributeNamespace(int index) {
return m_reader.getAttributeNamespace(index);
}
/**
* Get attribute namespace prefix for current START_ELEMENT event. The
* results are undefined if called when not at a START_ELEMENT event.
*
* @param index index number of attribute to be returned
* @return prefix for namespace of attribute at position, null
* if none
* @throws IllegalStateException if not at a start tag or invalid index
*/
public String getAttributePrefix(int index) {
return m_reader.getAttributePrefix(index);
}
/**
* Get attribute value for current START_ELEMENT event. The results are
* undefined if called when not at a START_ELEMENT event.
*
* @param index index number of attribute to be returned
* @return value of attribute at position
* @throws IllegalStateException if not at a start tag or invalid index
*/
public String getAttributeValue(int index) {
return m_reader.getAttributeValue(index);
}
/**
* Get number of namespace declarations for current START_ELEMENT event. The
* results are undefined if called when not at a START_ELEMENT event.
*
* @return number of namespace declarations, or -1 if not at
* START_ELEMENT
*/
public int getNamespaceCount() {
try {
int level = m_reader.getNestingDepth();
return m_reader.getNamespaceCount(level)-
m_reader.getNamespaceCount(level-1);
} catch (IllegalArgumentException e) {
throw new IllegalStateException("Internal error: " +
e.getMessage());
}
}
/**
* Get namespace URI for namespace declaration on current START_ELEMENT
* event. The results are undefined if called when not at a START_ELEMENT
* event.
*
* @param index index number of declaration to be returned
* @return namespace URI for declaration at position
* @throws IllegalArgumentException if invalid index
*/
public String getNamespaceUri(int index) {
int base = m_reader.getNamespaceCount(m_reader.getNestingDepth()-1);
return m_reader.getNamespaceUri(base + index);
}
/**
* Get namespace prefix for namespace declaration on current START_ELEMENT
* event. The results are undefined if called when not at a START_ELEMENT
* event.
*
* @param index index number of declaration to be returned
* @return namespace prefix for declaration at position,
* @throws IllegalArgumentException if invalid index
*/
public String getNamespacePrefix(int index) {
int base = m_reader.getNamespaceCount(m_reader.getNestingDepth()-1);
return m_reader.getNamespacePrefix(base + index);
}
/**
* Get namespace URI matching prefix.
*
* @param prefix namespace prefix to be matched (null for
* default namespace)
* @return namespace URI for prefix
*/
public String getNamespaceUri(String prefix) {
return m_reader.getNamespace(prefix);
}
/**
* Get text value for current event.
*
* @return text value for event
*/
public String getText() {
return m_reader.getText();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/USASCIIEscaper.java 0000644 0001750 0001750 00000016737 10071714404 025555 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
import java.io.Writer;
import org.jibx.runtime.ICharacterEscaper;
/**
* Handler for writing ASCII output stream. This code is specifically for XML
* 1.0 and would require changes for XML 1.1 (to handle the added legal
* characters, rather than throwing an exception).
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class USASCIIEscaper implements ICharacterEscaper
{
/** Singleton instance of class. */
private static final USASCIIEscaper s_instance = new USASCIIEscaper();
/**
* Private constructor to prevent external creation.
*/
private USASCIIEscaper() {}
/**
* Write attribute value with character entity substitutions. This assumes
* that attributes use the regular quote ('"') delimitor.
*
* @param text attribute value text
* @param writer sink for output text
* @throws IOException on error writing to document
*/
public void writeAttribute(String text, Writer writer) throws IOException {
int mark = 0;
for (int i = 0; i < text.length(); i++) {
char chr = text.charAt(i);
if (chr == '"') {
writer.write(text, mark, i-mark);
mark = i+1;
writer.write(""");
} else if (chr == '&') {
writer.write(text, mark, i-mark);
mark = i+1;
writer.write("&");
} else if (chr == '<') {
writer.write(text, mark, i-mark);
mark = i+1;
writer.write("<");
} else if (chr == '>' && i > 2 && text.charAt(i-1) == ']' &&
text.charAt(i-2) == ']') {
writer.write(text, mark, i-mark-2);
mark = i+1;
writer.write("]]>");
} else if (chr < 0x20) {
if (chr != 0x9 && chr != 0xA && chr != 0xD) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in attribute value text");
}
} else if (chr > 0x7F) {
writer.write(text, mark, i-mark);
mark = i+1;
if (chr > 0xD7FF && (chr < 0xE000 || chr == 0xFFFE ||
chr == 0xFFFF || chr > 0x10FFFF)) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in attribute value text");
}
writer.write("&#x");
writer.write(Integer.toHexString(chr));
writer.write(';');
}
}
writer.write(text, mark, text.length()-mark);
}
/**
* Write content value with character entity substitutions.
*
* @param text content value text
* @param writer sink for output text
* @throws IOException on error writing to document
*/
public void writeContent(String text, Writer writer) throws IOException {
int mark = 0;
for (int i = 0; i < text.length(); i++) {
char chr = text.charAt(i);
if (chr == '&') {
writer.write(text, mark, i-mark);
mark = i+1;
writer.write("&");
} else if (chr == '<') {
writer.write(text, mark, i-mark);
mark = i+1;
writer.write("<");
} else if (chr == '>' && i > 2 && text.charAt(i-1) == ']' &&
text.charAt(i-2) == ']') {
writer.write(text, mark, i-mark-2);
mark = i+1;
writer.write("]]>");
} else if (chr < 0x20) {
if (chr != 0x9 && chr != 0xA && chr != 0xD) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in content text");
}
} else if (chr > 0x7F) {
writer.write(text, mark, i-mark);
mark = i+1;
if (chr > 0xD7FF && (chr < 0xE000 || chr == 0xFFFE ||
chr == 0xFFFF || chr > 0x10FFFF)) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in content text");
}
writer.write("&#x");
writer.write(Integer.toHexString(chr));
writer.write(';');
}
}
writer.write(text, mark, text.length()-mark);
}
/**
* Write CDATA to document. This writes the beginning and ending sequences
* for a CDATA section as well as the actual text, verifying that only
* characters allowed by the encoding are included in the text.
*
* @param text content value text
* @param writer sink for output text
* @throws IOException on error writing to document
*/
public void writeCData(String text, Writer writer) throws IOException {
writer.write("' && i > 2 && text.charAt(i-1) == ']' &&
text.charAt(i-2) == ']') {
throw new IOException("Sequence \"]]>\" is not allowed " +
"within CDATA section text");
} else if (chr < 0x20) {
if (chr != 0x9 && chr != 0xA && chr != 0xD) {
throw new IOException("Illegal character code 0x" +
Integer.toHexString(chr) + " in CDATA section");
}
} else if (chr >= 0x80) {
throw new IOException("Character code 0x" +
Integer.toHexString(chr) +
" not supported by encoding in CDATA section");
}
}
writer.write(text);
writer.write("]]>");
}
/**
* Get instance of escaper.
*
* @return escaper instance
*/
public static ICharacterEscaper getInstance() {
return s_instance;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/BackFillReference.java 0000644 0001750 0001750 00000004233 10071714370 026426 0 ustar twerner twerner /*
Copyright (c) 2002,2003, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
/**
* Backfill reference item, used for filling in forward references to
* objects. Each reference to an item must define a class implementing
* this interface, to be used when a referenced item is not yet defined.
* The references for a particular object are collected by a BackFillHolder
* instance, and are processed when the object is defined.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public interface BackFillReference
{
/**
* Define referenced object. This method is called by the framework
* when the forward-referenced item is defined.
*
* @param obj referenced object
*/
public void backfill(Object obj);
}
libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/ArrayRangeIterator.java 0000644 0001750 0001750 00000007405 10257171674 026723 0 ustar twerner twerner /*
Copyright (c) 2000-2005, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* Iterator class for values contained in an array range. This type of iterator
* can be used for any contiguous range of items in an object array.
*
* @author Dennis M. Sosnoski
* @version 1.1
*/
public class ArrayRangeIterator implements Iterator
{
/** Empty iterator used whenever possible. */
public static final ArrayRangeIterator EMPTY_ITERATOR =
new ArrayRangeIterator(null, 0, 0);
/** Array supplying values for iteration. */
protected Object[] m_array;
/** Offset of next iteration value. */
protected int m_offset;
/** Ending offset for values. */
protected int m_limit;
/**
* Internal constructor.
*
* @param array array containing values to be iterated
* @param start starting offset in array
* @param limit offset past end of values
*/
private ArrayRangeIterator(Object[] array, int start, int limit) {
m_array = array;
m_offset = start;
m_limit = limit;
}
/**
* Check for iteration element available.
*
* @return true if element available, false if
* not
*/
public boolean hasNext() {
return m_offset < m_limit;
}
/**
* Get next iteration element.
*
* @return next iteration element
* @exception NoSuchElementException if past end of iteration
*/
public Object next() {
if (m_offset < m_limit) {
return m_array[m_offset++];
} else {
throw new NoSuchElementException();
}
}
/**
* Remove element from iteration. This optional operation is not supported
* and always throws an exception.
*
* @exception UnsupportedOperationException for unsupported operation
*/
public void remove() {
throw new UnsupportedOperationException();
}
/**
* Build iterator.
*
* @param array array containing values to be iterated (may be
* null)
* @param start starting offset in array
* @param limit offset past end of values
* @return constructed iterator
*/
public static Iterator buildIterator(Object[] array, int start, int limit) {
if (array == null || start >= limit) {
return EMPTY_ITERATOR;
} else {
return new ArrayRangeIterator(array, start, limit);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/StAXReaderWrapper.java 0000644 0001750 0001750 00000041360 11415066240 026444 0 ustar twerner twerner /*
Copyright (c) 2005-2010, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import javax.xml.stream.Location;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import org.jibx.runtime.IXMLReader;
import org.jibx.runtime.IntStack;
import org.jibx.runtime.JiBXException;
/**
* Wrapper for a StAX parser implementation. This delegates most calls
* more or less directly, only adding the required namespace functionality
* on top of the StAX API.
*/
public class StAXReaderWrapper implements IXMLReader
{
/** Event type code translation array. Indexed by the StAX event code, it
returns the corresponding XML reader event code. */
static final byte[] s_eventTranslations = new byte[256];
static {
s_eventTranslations[XMLStreamConstants.CDATA] = IXMLReader.CDSECT;
s_eventTranslations[XMLStreamConstants.CHARACTERS] = IXMLReader.TEXT;
s_eventTranslations[XMLStreamConstants.COMMENT] = IXMLReader.COMMENT;
s_eventTranslations[XMLStreamConstants.DTD] = IXMLReader.DOCDECL;
s_eventTranslations[XMLStreamConstants.END_DOCUMENT] =
IXMLReader.END_DOCUMENT;
s_eventTranslations[XMLStreamConstants.END_ELEMENT] =
IXMLReader.END_TAG;
s_eventTranslations[XMLStreamConstants.ENTITY_REFERENCE] =
IXMLReader.ENTITY_REF;
s_eventTranslations[XMLStreamConstants.PROCESSING_INSTRUCTION] =
IXMLReader.PROCESSING_INSTRUCTION;
s_eventTranslations[XMLStreamConstants.SPACE] =
IXMLReader.IGNORABLE_WHITESPACE;
s_eventTranslations[XMLStreamConstants.START_DOCUMENT] =
IXMLReader.START_DOCUMENT;
s_eventTranslations[XMLStreamConstants.START_ELEMENT] =
IXMLReader.START_TAG;
}
/** Actual parser. */
private final XMLStreamReader m_parser;
/** Parser processing namespaces flag. */
final boolean m_isNamespaceAware;
/** Document name. */
private final String m_docName;
/** Current element nesting depth. */
int m_nestingDepth;
/** Namespace definitions in scope at each nesting depth. */
private IntStack m_inScopeCounts;
/** Namespace URIs in scope. */
private GrowableStringArray m_inScopeUris;
/** Namespace prefixes in scope. */
private GrowableStringArray m_inScopePrefixes;
/** Accumulated text for return. */
private String m_accumulatedText;
/** Accumulated text is processing instruction flag (otherwise content) */
private boolean m_isProcessingInstruction;
/** Document encoding (apparently cannot be read after parse done). */
private String m_encoding;
/**
* Constructor used by factory. This checks the parser state, and if
* positioned at a start tag it initializes the namespace information for
* that start tag.
*
* @param rdr event reader
* @param name document name
* @param nsa namespace aware flag
*/
public StAXReaderWrapper(XMLStreamReader rdr, String name, boolean nsa) {
m_parser = rdr;
m_docName = name;
m_isNamespaceAware = nsa;
m_inScopeCounts = new IntStack();
m_inScopeCounts.push(0);
m_inScopeUris = new GrowableStringArray();
m_inScopePrefixes = new GrowableStringArray();
if (rdr.isStartElement()) {
startTag();
}
}
/**
* Initialize reader.
*/
public void init() {
}
/**
* Build current parse input position description.
*
* @return text description of current parse position
*/
public String buildPositionString() {
Location location = m_parser.getLocation();
String base = "(line " + location.getLineNumber() + ", col " +
location.getColumnNumber();
if (m_docName != null) {
base += ", in " + m_docName;
}
return base + ')';
}
/**
* Handle start tag. This increments the nesting count, and records all
* namespaces associated with the start tag.
*/
private void startTag() {
m_nestingDepth++;
int count = m_parser.getNamespaceCount();
for (int i = 0; i < count; i++) {
m_inScopeUris.add(m_parser.getNamespaceURI(i));
m_inScopePrefixes.add(m_parser.getNamespacePrefix(i));
}
m_inScopeCounts.push(m_inScopeUris.size());
}
/**
* Handle end tag. This decrements the nesting count, and deletes all
* namespaces associated with the start tag.
*/
private void endTag() {
m_nestingDepth--;
int count = m_inScopeCounts.pop() -
(m_nestingDepth > 0 ? m_inScopeCounts.peek() : 0);
if (count > 0) {
m_inScopeUris.remove(count);
m_inScopePrefixes.remove(count);
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#nextToken()
*/
public int nextToken() throws JiBXException {
if (m_accumulatedText == null) {
try {
int code;
loop: while (true) {
code = s_eventTranslations[m_parser.next()];
switch (code) {
case START_TAG:
startTag();
break loop;
case END_TAG:
endTag();
break loop;
case PROCESSING_INSTRUCTION:
m_accumulatedText = m_parser.getPITarget() + ' ' +
m_parser.getPIData();
m_isProcessingInstruction = true;
while (s_eventTranslations[m_parser.next()] == 0);
break loop;
case 0:
break;
default:
break loop;
}
}
return code;
} catch (XMLStreamException e) {
throw new JiBXException
("Error parsing document " + buildPositionString(), e);
}
} else {
m_accumulatedText = null;
m_isProcessingInstruction = false;
int code = s_eventTranslations[m_parser.getEventType()];
if (code == START_TAG) {
startTag();
} else if (code == END_TAG) {
endTag();
}
return code;
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#next()
*/
public int next() throws JiBXException {
String text = null;
StringBuffer buff = null;
try {
if (m_nestingDepth == 0 &&
m_parser.getEventType() == XMLStreamConstants.START_DOCUMENT) {
m_encoding = m_parser.getEncoding();
if (m_encoding == null) {
m_encoding = m_parser.getCharacterEncodingScheme();
}
}
int type;
if (m_accumulatedText == null) {
m_parser.next();
} else {
m_accumulatedText = null;
m_isProcessingInstruction = false;
}
loop: while (true) {
type = s_eventTranslations[m_parser.getEventType()];
switch (type) {
case ENTITY_REF:
if (m_parser.getText() == null) {
throw new JiBXException
("Unexpanded entity reference in text at " +
buildPositionString());
}
// fall through into text accumulation
case CDSECT:
case TEXT:
if (text == null) {
text = m_parser.getText();
} else {
if (buff == null) {
buff = new StringBuffer(text);
}
buff.append(m_parser.getTextCharacters());
}
break;
case END_TAG:
if (text == null) {
endTag();
return type;
}
break loop;
case START_TAG:
if (text == null) {
startTag();
return type;
}
break loop;
case END_DOCUMENT:
if (text == null) {
return type;
}
break loop;
default:
break;
}
m_parser.next();
}
if (buff == null) {
m_accumulatedText = text;
} else {
m_accumulatedText = buff.toString();
}
return TEXT;
} catch (XMLStreamException e) {
throw new JiBXException
("Error parsing document " + buildPositionString(), e);
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getEventType()
*/
public int getEventType() throws JiBXException {
if (m_accumulatedText == null) {
return s_eventTranslations[m_parser.getEventType()];
} else if (m_isProcessingInstruction) {
return PROCESSING_INSTRUCTION;
} else {
return TEXT;
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getName()
*/
public String getName() {
return m_parser.getLocalName();
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getNamespace()
*/
public String getNamespace() {
String uri = m_parser.getNamespaceURI();
if (uri == null) {
return "";
} else {
return uri;
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getPrefix()
*/
public String getPrefix() {
String prefix = m_parser.getPrefix();
if (prefix != null && prefix.length() == 0) {
return null;
} else {
return prefix;
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getAttributeCount()
*/
public int getAttributeCount() {
return m_parser.getAttributeCount();
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getAttributeName(int)
*/
public String getAttributeName(int index) {
try {
return m_parser.getAttributeLocalName(index);
} catch (ArrayIndexOutOfBoundsException e) {
throw new IllegalStateException(e.getMessage());
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getAttributeNamespace(int)
*/
public String getAttributeNamespace(int index) {
try {
String uri = m_parser.getAttributeNamespace(index);
if (uri == null) {
return "";
} else {
return uri;
}
} catch (ArrayIndexOutOfBoundsException e) {
throw new IllegalStateException(e.getMessage());
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getAttributePrefix(int)
*/
public String getAttributePrefix(int index) {
try {
String prefix = m_parser.getAttributePrefix(index);
if (prefix != null && prefix.length() == 0) {
return null;
} else {
return prefix;
}
} catch (ArrayIndexOutOfBoundsException e) {
throw new IllegalStateException(e.getMessage());
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getAttributeValue(int)
*/
public String getAttributeValue(int index) {
try {
return m_parser.getAttributeValue(index);
} catch (ArrayIndexOutOfBoundsException e) {
throw new IllegalStateException(e.getMessage());
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getAttributeValue(java.lang.String, java.lang.String)
*/
public String getAttributeValue(String ns, String name) {
// note that due to the under-specified StAX API there's no way to
// directly check for a non-namespaced attribute, since null means
// match any namespace and the empty string is not supported by all
// implementations as meaning non-namespaced
return m_parser.getAttributeValue(ns, name);
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getText()
*/
public String getText() {
if (m_accumulatedText == null) {
return m_parser.getText();
} else {
return m_accumulatedText;
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getNestingDepth()
*/
public int getNestingDepth() {
return m_nestingDepth;
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getNamespaceCount(int)
*/
public int getNamespaceCount(int depth) {
return m_inScopeCounts.peek(m_nestingDepth-depth);
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getNamespaceUri(int)
*/
public String getNamespaceUri(int index) {
return m_inScopeUris.get(index);
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getNamespacePrefix(int)
*/
public String getNamespacePrefix(int index) {
String prefix = m_inScopePrefixes.get(index);
if (prefix != null && prefix.length() == 0) {
return null;
} else {
return prefix;
}
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getDocumentName()
*/
public String getDocumentName() {
return m_docName;
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getLineNumber()
*/
public int getLineNumber() {
return m_parser.getLocation().getLineNumber();
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getColumnNumber()
*/
public int getColumnNumber() {
return m_parser.getLocation().getColumnNumber();
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getNamespace(java.lang.String)
*/
public String getNamespace(String prefix) {
int index = m_inScopePrefixes.size();
while (--index >= 0) {
String comp = m_inScopePrefixes.get(index);
if ((prefix == null && comp == null) ||
(prefix != null && prefix.equals(comp))) {
return m_inScopeUris.get(index);
}
}
return null;
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#getInputEncoding()
*/
public String getInputEncoding() {
return m_encoding == null ? "UTF-8" : m_encoding;
}
/* (non-Javadoc)
* @see org.jibx.runtime.IXMLReader#isNamespaceAware()
*/
public boolean isNamespaceAware() {
return m_isNamespaceAware;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/InputStreamWrapper.java 0000644 0001750 0001750 00000055156 11067527564 027003 0 ustar twerner twerner /*
Copyright (c) 2004-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime.impl;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
/**
* Wrapper for input buffer that supports multiple character encodings. This is
* needed because the XPP3 pull parser does not support detecting the character
* encoding for a document based on the content of the document. If used with a
* common encoding this performs the conversion to characters using an inner
* reader class; otherwise, this creates the appropriate reader type
*
* @author Dennis M. Sosnoski
*/
public class InputStreamWrapper
{
/** Input buffer. */
private IInByteBuffer m_byteBuffer;
/** Name of encoding to be used for stream. */
private String m_encodingName;
/** Cached reference to byte array used by buffer. */
private byte[] m_buffer;
/** Offset past end of bytes in buffer. */
private int m_endOffset;
/** Current offset for generating character from buffer. */
private int m_emptyOffset;
/** Scan position offset used for lookahead in buffer. */
private int m_scanOffset;
/**
* Set the input buffer.
*
* @param buff
*/
public void setBuffer(IInByteBuffer buff) {
m_byteBuffer = buff;
m_buffer = buff.getBuffer();
m_endOffset = buff.getLimit();
m_emptyOffset = buff.getOffset();
}
/**
* Get input buffer.
*
* @return buffer, null if none set
*/
public IInByteBuffer getBuffer() {
return m_byteBuffer;
}
/**
* Set encoding for stream. This call is only valid if the encoding has not
* been set previously, and if the encoding is a recognized type.
*
* @param enc character encoding used for input from stream
* (null if to be determined from XML input)
* @throws IOException if unknown encoding, or encoding already set
*/
public void setEncoding(String enc) throws IOException {
if (m_encodingName == null) {
m_encodingName = enc;
} else {
throw new IOException("Encoding has already been set for stream");
}
}
/**
* Reads data into the buffer. The actual number of bytes read by a call to
* this method is normally between one and the space available in the buffer
* array.
*
* @return true if data has been read into buffer,
* false if not
* @throws IOException on error reading from stream
*/
private boolean fillBuffer() throws IOException {
m_byteBuffer.setOffset(m_emptyOffset);
int remain = m_endOffset - m_emptyOffset;
boolean result = m_byteBuffer.require(remain+1);
m_buffer = m_byteBuffer.getBuffer();
m_endOffset = m_byteBuffer.getLimit();
m_emptyOffset = m_byteBuffer.getOffset();
return result;
}
/**
* Reads data into the buffer to at least a minimum number of bytes. Any
* retained data is first copied down to the start of the buffer array.
* Next, data is read from the wrapped stream into the available space in
* the buffer until the end of the input stream is reached or at least the
* requested number of bytes are present in the buffer.
*
* @param min number of bytes required
* @return true if buffer contains at least the required byte
* count on return, false if not
* @throws IOException on error reading from wrapped stream
*/
private boolean require(int min) throws IOException {
boolean result = true;
if (m_endOffset - m_emptyOffset < min) {
m_byteBuffer.setOffset(m_emptyOffset);
result = m_byteBuffer.require(min);
m_buffer = m_byteBuffer.getBuffer();
m_endOffset = m_byteBuffer.getLimit();
m_emptyOffset = m_byteBuffer.getOffset();
}
return result;
}
/**
* Check if a character is XML whitespace.
*
* @param chr
* @return true if whitespace, false if not
*/
private boolean isWhite(int chr) {
return chr == ' ' || chr == 0x09 || chr == 0x0A || chr == 0x0D;
}
/**
* Reads a space or equals ('=') delimited token from the scan position in
* the buffer. This treats bytes in the buffer as equivalent to characters.
* Besides ending a token on a delimitor, it also ends a token after adding
* a greater-than ('>') character.
*
* @return token read from buffer
* @throws IOException on error reading from wrapped stream
*/
private String scanToken() throws IOException {
boolean skipping = true;
StringBuffer buff = new StringBuffer();
while (require(m_scanOffset+1)) {
char chr = (char)m_buffer[m_scanOffset++];
if (skipping) {
if (!isWhite(chr)) {
skipping = false;
buff.append(chr);
if (chr == '=') {
return buff.toString();
}
}
} else if (isWhite(chr) || chr == '=') {
m_scanOffset--;
return buff.toString();
} else {
buff.append(chr);
if (chr == '>') {
return buff.toString();
}
}
}
return null;
}
/**
* Reads a quote delimited token from the scan position in the buffer. This
* treats bytes in the buffer as equivalent to characters, and skips past
* any leading whitespace.
*
* @return token read from buffer
* @throws IOException on error reading from wrapped stream
*/
private String scanQuoted() throws IOException {
boolean skipping = true;
int quot = 0;
StringBuffer buff = new StringBuffer();
while (require(m_scanOffset+1)) {
char chr = (char)m_buffer[m_scanOffset++];
if (skipping) {
if (!isWhite(chr)) {
if (chr == '"' || chr == '\'') {
skipping = false;
quot = chr;
} else {
break;
}
}
} else if (chr == quot) {
return buff.toString();
} else {
buff.append(chr);
}
}
return null;
}
/**
* Get reader for wrapped input stream. This creates and returns a reader
* using the appropriate encoding, if necessary reading and examining the
* first part of the stream (including the XML declaration, if present) to
* determine the encoding.
*
* @return reader
* @throws IOException if error reading from document or creating a reader
* for the encoding found
*/
public Reader getReader() throws IOException {
// check if we need to determine an encoding
if (m_encodingName == null) {
// try to get enough input to decide if anything other than default
m_encodingName = "UTF-8";
if (require(4)) {
// get first four bytes for initial determination
int bom = (((m_buffer[0] << 8) + (m_buffer[1] & 0xFF) << 8) +
(m_buffer[2] & 0xFF) << 8) + (m_buffer[3] & 0xFF);
if (bom == 0x3C3F786D) {
// read encoding declaration with single byte characters
m_scanOffset = 2;
String token = scanToken();
if ("xml".equals(token)) {
while ((token = scanToken()) != null &&
!"?>".equals(token)) {
if ("encoding".equals(token)) {
if ("=".equals(scanToken())) {
token = scanQuoted();
if (token != null) {
m_encodingName = token;
break;
}
}
} else if ("=".equals(token)) {
scanQuoted();
}
}
}
} else if (bom == 0x0000FEFF || bom == 0xFFFE0000 ||
bom == 0x0000FFFE || bom == 0xFEFF0000) {
// just use generic UCS-4 and let libraries figure it out
m_encodingName = "UCS-4";
} else if ((bom & 0xFFFFFF00) == 0xEFBBBF00) {
// UTF-8 as specified by byte order mark
m_encodingName = "UTF-8";
} else {
int upper = bom & 0xFFFF0000;
if (upper == 0xFEFF0000 || bom == 0x003C003F) {
// assume UTF-16BE for 16-bit BE
m_encodingName = "UTF-16BE";
} else if (upper == 0xFFFE0000 || bom == 0x3C003F00) {
// assume UTF-16LE for 16-bit LE
m_encodingName = "UTF-16LE";
} else if (bom == 0x4C6FA794){
// just because we can, even though nobody should
m_encodingName = "EBCDIC";
}
}
}
}
if (m_encodingName.equalsIgnoreCase("UTF-8")) {
return new WrappedStreamUTF8Reader();
} else if (m_encodingName.equalsIgnoreCase("ISO-8859-1") ||
m_encodingName.equalsIgnoreCase("ASCII")) {
return new WrappedStreamISO88591Reader();
} else {
return new InputStreamReader(new WrappedStream(), m_encodingName);
}
}
/**
* Get encoding for input document. This call may not return an accurate
* result until after {@link #getReader} is called.
*
* @return character encoding for input document
*/
public String getEncoding() {
return m_encodingName;
}
/**
* Close document input. Completes reading of document input, including
* closing the input medium.
*
* @throws IOException on error closing document
*/
public void close() throws IOException {
if (m_byteBuffer != null) {
m_byteBuffer.finish();
}
reset();
}
/**
* Reset to initial state for reuse.
*/
public void reset() {
m_scanOffset = 0;
m_endOffset = 0;
m_emptyOffset = 0;
m_encodingName = null;
}
/**
* Stream that just uses the enclosing class to buffer input from the
* wrapped stream.
*/
private class WrappedStream extends InputStream
{
/* (non-Javadoc)
* @see java.io.InputStream#available()
*/
public int available() throws IOException {
if (m_emptyOffset >= m_endOffset) {
m_byteBuffer.require(1);
m_buffer = m_byteBuffer.getBuffer();
m_emptyOffset = m_byteBuffer.getOffset();
m_endOffset = m_byteBuffer.getLimit();
}
return m_endOffset - m_emptyOffset ;
}
/* (non-Javadoc)
* @see java.io.InputStream#close()
*/
public void close() throws IOException {
InputStreamWrapper.this.close();
}
/* (non-Javadoc)
* @see java.io.InputStream#read(byte[], int, int)
*/
public int read(byte[] b, int off, int len) throws IOException {
int avail;
int actual = 0;
while (len > (avail = m_endOffset - m_emptyOffset)) {
System.arraycopy(m_buffer, m_emptyOffset, b, off, avail);
off += avail;
len -= avail;
actual += avail;
m_emptyOffset = m_endOffset;
if (!fillBuffer()) {
return actual == 0 ? -1 : actual;
}
}
System.arraycopy(m_buffer, m_emptyOffset, b, off, len);
m_emptyOffset += len;
return actual + len;
}
/* (non-Javadoc)
* @see java.io.InputStream#read(byte[])
*/
public int read(byte[] b) throws IOException {
return read(b, 0, b.length);
}
/* (non-Javadoc)
* @see java.io.InputStream#skip(long)
*/
public long skip(long n) throws IOException {
int avail;
long remain = n;
while (remain > (avail = m_endOffset - m_emptyOffset)) {
remain -= avail;
m_emptyOffset = m_endOffset;
if (!fillBuffer()) {
return n-remain;
}
}
m_emptyOffset += remain;
return n;
}
/* (non-Javadoc)
* @see java.io.InputStream#read()
*/
public int read() throws IOException {
if (m_emptyOffset >= m_endOffset && !fillBuffer()) {
return -1;
} else {
return m_buffer[m_emptyOffset++];
}
}
}
/**
* Reader for input stream using UTF-8 encoding. This uses the enclosing
* class to buffer input from the stream, interpreting it as characters on
* demand.
*/
private class WrappedStreamUTF8Reader extends Reader
{
/* (non-Javadoc)
* @see java.io.Reader#close()
*/
public void close() throws IOException {
InputStreamWrapper.this.close();
}
/* (non-Javadoc)
* @see java.io.Reader#read(char[], int, int)
*/
public int read(char[] b, int off, int len) throws IOException {
// load up local variables for conversion loop
int end = off + len;
int empty = m_emptyOffset;
byte[] buff = m_buffer;
while (off < end) {
// fill buffer if less than maximum byte count in character
if (empty + 3 > m_endOffset) {
m_emptyOffset = empty;
fillBuffer();
empty = m_emptyOffset;
if (empty == m_endOffset) {
int actual = len + off - end;
return actual > 0 ? actual : -1;
}
}
// check for single-byte vs multi-byte character next
int byt = buff[empty++];
if (byt >= 0) {
// single-byte character, just store to output array
b[off++] = (char)byt;
} else if ((byt & 0xE0) == 0xC0) {
// double-byte character, check bytes available and store
if (empty < m_endOffset) {
// TODO: check second byte value
b[off++] = (char)(((byt & 0x1F) << 6) +
(buff[empty++] & 0x3F));
} else {
throw new IOException("UTF-8 conversion error");
}
} else if ((byt & 0xF0) == 0xE0) {
// three-byte character, check bytes available and store
if (empty + 1 < m_endOffset) {
// TODO: check second and third byte values
int byt2 = buff[empty++] & 0x3F;
b[off++] = (char)((((byt & 0x0F) << 6) +
byt2 << 6) + (buff[empty++] & 0x3F));
} else {
throw new IOException("UTF-8 conversion error");
}
} else {
// TODO: implement surrogate pair handling
throw new IOException("Surrogate pairs not yet supported");
}
}
m_emptyOffset = empty;
return len;
}
/* (non-Javadoc)
* @see java.io.Reader#read(char[])
*/
public int read(char[] b) throws IOException {
return read(b, 0, b.length);
}
/* (non-Javadoc)
* @see java.io.Reader#read()
*/
public int read() throws IOException {
// fill buffer if less than maximum byte count in character
if (m_emptyOffset + 3 > m_endOffset) {
fillBuffer();
if (m_emptyOffset == m_endOffset) {
return -1;
}
}
// check for single-byte vs multi-byte character next
int byt = m_buffer[m_emptyOffset++];
if (byt >= 0) {
// single-byte character, just store to output array
return byt & 0xFF;
} else if ((byt & 0xE0) == 0xC0) {
// double-byte character, check bytes available and store
if (m_emptyOffset < m_endOffset) {
// TODO: check second byte value
return ((byt & 0x1F) << 6) +
(m_buffer[m_emptyOffset++] & 0x3F);
} else {
throw new IOException("UTF-8 conversion error");
}
} else if ((byt & 0xF0) == 0xE0) {
// three-byte character, check bytes available and store
if (m_emptyOffset + 1 < m_endOffset) {
// TODO: check second and third byte values
int byt2 = m_buffer[m_emptyOffset++] & 0x3F;
return (((byt & 0x0F) << 6) +
byt2 << 6) + (m_buffer[m_emptyOffset++] & 0x3F);
} else {
throw new IOException("UTF-8 conversion error");
}
} else {
// TODO: implement surrogate pair handling
throw new IOException("Surrogate pairs not yet supported");
}
}
/* (non-Javadoc)
* @see java.io.Reader#ready()
*/
public boolean ready() throws IOException {
return m_emptyOffset + 2 < m_endOffset;
}
}
/**
* Reader for input stream using ISO8859-1 encoding. This uses the enclosing
* class to buffer input from the stream, interpreting it as characters on
* demand.
*/
private class WrappedStreamISO88591Reader extends Reader
{
/* (non-Javadoc)
* @see java.io.Reader#close()
*/
public void close() throws IOException {
InputStreamWrapper.this.close();
}
/* (non-Javadoc)
* @see java.io.Reader#read(char[], int, int)
*/
public int read(char[] b, int off, int len) throws IOException {
// load up local variables for conversion loop
int end = off + len;
int empty = m_emptyOffset;
byte[] buff = m_buffer;
while (off < end) {
// make sure there's data in buffer
int avail = m_endOffset - empty;
if (avail == 0) {
m_emptyOffset = empty;
if (fillBuffer()) {
empty = m_emptyOffset;
avail = m_endOffset - empty;
} else {
int actual = len + off - end;
return actual > 0 ? actual : -1;
}
}
// find count of bytes to convert to characters
int use = end - off;
if (use > avail) {
use = avail;
}
// convert bytes directly to characters
int limit = empty + use;
while (empty < limit) {
b[off++] = (char)(buff[empty++] & 0xFF);
}
}
m_emptyOffset = empty;
return len;
}
/* (non-Javadoc)
* @see java.io.Reader#read(char[])
*/
public int read(char[] b) throws IOException {
return read(b, 0, b.length);
}
/* (non-Javadoc)
* @see java.io.Reader#read()
*/
public int read() throws IOException {
if (m_emptyOffset >= m_endOffset && !fillBuffer()) {
return -1;
} else {
return m_buffer[m_emptyOffset++] & 0xFF;
}
}
/* (non-Javadoc)
* @see java.io.Reader#ready()
*/
public boolean ready() throws IOException {
return m_emptyOffset < m_endOffset;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/impl/SparseArrayIterator.java 0000644 0001750 0001750 00000006712 10257171674 027124 0 ustar twerner twerner /*
* Copyright (c) 2000-2001 Sosnoski Software Solutions, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
package org.jibx.runtime.impl;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* Iterator class for sparse values in an array. This type of iterator
* can be used for an object array which has references interspersed with
* nulls.
*
* @author Dennis M. Sosnoski
* @version 1.1
*/
public class SparseArrayIterator implements Iterator
{
/** Array supplying values for iteration. */
protected Object[] m_array;
/** Offset of next iteration value. */
protected int m_offset;
/**
* Internal constructor.
*
* @param array array containing values to be iterated
*/
private SparseArrayIterator(Object[] array) {
m_array = array;
m_offset = -1;
advance();
}
/**
* Advance to next iteration value. This advances the current position in
* the array to the next non-null value.
*
* @return true if element available, false if
* not
*/
protected boolean advance() {
while (++m_offset < m_array.length) {
if (m_array[m_offset] != null) {
return true;
}
}
return false;
}
/**
* Check for iteration element available.
*
* @return true if element available, false if
* not
*/
public boolean hasNext() {
return m_offset < m_array.length;
}
/**
* Get next iteration element.
*
* @return next iteration element
* @exception NoSuchElementException if past end of iteration
*/
public Object next() {
if (m_offset < m_array.length) {
Object result = m_array[m_offset];
advance();
return result;
} else {
throw new NoSuchElementException();
}
}
/**
* Remove element from iteration. This optional operation is not supported
* and always throws an exception.
*
* @exception UnsupportedOperationException for unsupported operation
*/
public void remove() {
throw new UnsupportedOperationException();
}
/**
* Build iterator.
*
* @param array array containing values to be iterated (may be
* null)
* @return constructed iterator
*/
public static Iterator buildIterator(Object[] array) {
if (array == null || array.length == 0) {
return ArrayRangeIterator.EMPTY_ITERATOR;
} else {
return new SparseArrayIterator(array);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/WhitespaceConversions.java 0000644 0001750 0001750 00000021777 11262211332 026531 0 ustar twerner twerner /*
* Copyright (c) 2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.runtime;
/**
* Utilities for handling whitespace options.
*
* @author Dennis M. Sosnoski
*/
public final class WhitespaceConversions
{
/** Non-constructor for class with no instances. */
private WhitespaceConversions() {}
/**
* Convert string value to whitespace-replaced form. The first character to be replaced must have been found prior
* to this call.
*
* @param text value to be converted
* @param index first character offset to be dropped from result
* @return collapsed string value
*/
private static String convertReplaced(String text, int index) {
// allocate and initialize copy to first replacement
int length = text.length();
StringBuffer buff = new StringBuffer(length - 1);
for (int i = 0; i < index; i++) {
buff.append(text.charAt(i));
}
// copy remainder of text, one character at a time
while (index < length) {
char chr = text.charAt(index++);
switch (chr)
{
case 0x09:
case 0x0A:
case 0x0D:
// replace other whitespace with space character
buff.append(' ');
break;
default:
// copy actual character to result buffer
buff.append(chr);
break;
}
}
return buff.toString();
}
/**
* Replace non-space whitespace in string. This first scans to see if any non-space whitespace is present, and if
* so, invokes the actual conversion handling.
*
* @param text value to be converted (null if none)
* @return replaced string value (null if none)
*/
public static String replace(String text) {
// just exit if no text
if (text == null) {
return null;
}
// scan through characters to check if conversion needed
int index;
int length = text.length();
loop: for (index = 0; index < length; index++) {
switch (text.charAt(index))
{
case 0x09:
case 0x0A:
case 0x0D:
// exit when any non-space whitespace is found
break loop;
}
}
// convert if character needs to be dropped
if (index < length) {
return convertReplaced(text, index);
} else {
return text;
}
}
/**
* Convert string value to whitespace-collapsed form. The first whitespace character must have been found prior to
* this call.
*
* @param text value to be converted
* @param index first character offset to be dropped from result
* @return collapsed string value
*/
private static String convertCollapsed(String text, int index) {
// allocate and initialize copy to first drop
int length = text.length();
StringBuffer buff = new StringBuffer(length - 1);
if (index > 0) {
// copy all the non-whitespace characters
for (int i = 0; i < index; i++) {
buff.append(text.charAt(i));
}
// append a single space to replace any whitespace sequence
buff.append(' ');
}
// copy remainder of text, one character at a time
boolean drop = true;
while (++index < length) {
char chr = text.charAt(index);
switch (chr)
{
case 0x09:
case 0x0A:
case 0x0D:
case ' ':
if (!drop) {
// replace first whitespace in sequence with single space
buff.append(' ');
drop = true;
}
break;
default:
// copy character to result buffer
buff.append(chr);
drop = false;
break;
}
}
// finish by deleting trailing whitespace
if (drop && buff.length() > 0) {
buff.setLength(buff.length()-1);
}
return buff.toString();
}
/**
* Collapse whitespace in string. This first scans to see if any whitespace is present, and if so, invokes the
* actual conversion handling.
*
* @param text value to be converted (null if none)
* @return collapsed string value (null if none)
*/
public static String collapse(String text) {
// just exit if no text
if (text == null) {
return null;
}
// scan through characters to check if conversion needed
int index;
int length = text.length();
loop: for (index = 0; index < length; index++) {
switch (text.charAt(index))
{
case 0x09:
case 0x0A:
case 0x0D:
case ' ':
// exit when any whitespace is found
break loop;
}
}
// convert if character needs to be dropped
if (index < length) {
return convertCollapsed(text, index);
} else {
return text;
}
}
/**
* Trim leading and trailing whitespace in string.
*
* @param text value to be converted (null if none)
* @return trimmed string value (null if none)
*/
public static String trim(String text) {
// just exit if nothing to be done
if (text == null) {
return null;
}
// scan through characters to skip leading whitespace
int length = text.length();
int start;
loop: for (start = 0; start < length; start++) {
switch (text.charAt(start))
{
case 0x09:
case 0x0A:
case 0x0D:
case ' ':
break;
default:
// exit when any non-whitespace is found
break loop;
}
}
if (start < length) {
// scan through characters to skip trailing whitespace
int end;
loop: for (end = length-1; ; end--) {
switch (text.charAt(end))
{
case 0x09:
case 0x0A:
case 0x0D:
case ' ':
break;
default:
// exit when any non-whitespace is found
break loop;
}
}
// return only the trimmed portion of string
end++;
if (start > 0 || end < length) {
return text.substring(start, end);
} else {
return text;
}
} else {
return "";
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/IUnmarshallingContext.java 0000644 0001750 0001750 00000024412 11043445700 026460 0 ustar twerner twerner /*
Copyright (c) 2002-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import java.io.InputStream;
import java.io.Reader;
/**
* User interface for deserializer from XML. This provides methods used to set
* up and control the marshalling process, as well as access to the
* unmarshalling object stack while unmarshalling.
*
* @author Dennis M. Sosnoski
*/
public interface IUnmarshallingContext {
/**
* Set document to be parsed from stream.
*
* @param ins stream supplying document data
* @param enc document input encoding, or null if to be
* determined by parser
* @throws JiBXException if error creating parser
*/
void setDocument(InputStream ins, String enc) throws JiBXException;
/**
* Set document to be parsed from reader.
*
* @param rdr reader supplying document data
* @throws JiBXException if error creating parser
*/
void setDocument(Reader rdr) throws JiBXException;
/**
* Set named document to be parsed from stream.
*
* @param ins stream supplying document data
* @param name document name
* @param enc document input encoding, or null if to be
* determined by parser
* @throws JiBXException if error creating parser
*/
void setDocument(InputStream ins, String name, String enc)
throws JiBXException;
/**
* Set named document to be parsed from reader.
*
* @param rdr reader supplying document data
* @param name document name
* @throws JiBXException if error creating parser
*/
void setDocument(Reader rdr, String name) throws JiBXException;
/**
* Reset unmarshalling information. This releases all references to
* unmarshalled objects and prepares the context for potential reuse.
* It is automatically called when input is set.
*/
void reset();
/**
* Unmarshal the current element. If not currently positioned at a start
* or end tag this first advances the parse to the next start or end tag.
* There must be an unmarshalling defined for the current element, and this
* unmarshalling is used to build an object from that element.
*
* @return unmarshalled object from element
* @throws JiBXException on any error (possibly wrapping other exception)
*/
Object unmarshalElement() throws JiBXException;
/**
* Unmarshal document from stream to object. The effect of this is the same
* as if {@link #setDocument} were called, followed by {@link
* #unmarshalElement}
*
* @param ins stream supplying document data
* @param enc document input encoding, or null if to be
* determined by parser
* @return unmarshalled object
* @throws JiBXException if error creating parser
*/
Object unmarshalDocument(InputStream ins, String enc) throws JiBXException;
/**
* Unmarshal document from reader to object. The effect of this is the same
* as if {@link #setDocument} were called, followed by {@link
* #unmarshalElement}
*
* @param rdr reader supplying document data
* @return unmarshalled object
* @throws JiBXException if error creating parser
*/
Object unmarshalDocument(Reader rdr) throws JiBXException;
/**
* Unmarshal named document from stream to object. The effect of this is the
* same as if {@link #setDocument} were called, followed by {@link
* #unmarshalElement}
*
* @param ins stream supplying document data
* @param name document name
* @param enc document input encoding, or null if to be
* determined by parser
* @return unmarshalled object
* @throws JiBXException if error creating parser
*/
Object unmarshalDocument(InputStream ins, String name, String enc)
throws JiBXException;
/**
* Unmarshal named document from reader to object. The effect of this is the
* same as if {@link #setDocument} were called, followed by {@link
* #unmarshalElement}
*
* @param rdr reader supplying document data
* @param name document name
* @return unmarshalled object
* @throws JiBXException if error creating parser
*/
Object unmarshalDocument(Reader rdr, String name) throws JiBXException;
/**
* Return the supplied document name.
*
* @return supplied document name (null if none)
*/
String getDocumentName();
/**
* Check if next tag is start of element. If not currently positioned at a
* start or end tag this first advances the parse to the next start or end
* tag.
*
* @param ns namespace URI for expected element (may be null
* or the empty string for the empty namespace)
* @param name element name expected
* @return true if at start of element with supplied name,
* false if not
* @throws JiBXException on any error (possibly wrapping other exception)
*/
boolean isAt(String ns, String name) throws JiBXException;
/**
* Check if next tag is a start tag. If not currently positioned at a
* start or end tag this first advances the parse to the next start or
* end tag.
*
* @return true if at start of element, false if
* at end
* @throws JiBXException on any error (possibly wrapping other exception)
*/
boolean isStart() throws JiBXException;
/**
* Check if next tag is an end tag. If not currently positioned at a
* start or end tag this first advances the parse to the next start or
* end tag.
*
* @return true if at end of element, false if
* at start
* @throws JiBXException on any error (possibly wrapping other exception)
*/
boolean isEnd() throws JiBXException;
/**
* Find the unmarshaller for a particular class in the current context.
*
* @param mapname unmarshaller mapping name (generally the class name to be
* handled, or abstract mapping type name)
* @return unmarshalling handler for class
* @throws JiBXException if unable to create unmarshaller
*/
IUnmarshaller getUnmarshaller(String mapname) throws JiBXException;
/**
* Set a user context object. This context object is not used directly by
* JiBX, but can be accessed by all types of user extension methods. The
* context object is automatically cleared by the {@link #reset()} method,
* so to make use of this you need to first call the appropriate version of
* the setDocument() method, then this method, and finally the
* {@link #unmarshalElement} method.
*
* @param obj user context object, or null if clearing existing
* context object
* @see #getUserContext()
*/
void setUserContext(Object obj);
/**
* Get the user context object.
*
* @return user context object, or null if no context object
* set
* @see #setUserContext(Object)
*/
Object getUserContext();
/**
* Push created object to unmarshalling stack. This must be called before
* beginning the unmarshalling of the object. It is only called for objects
* with structure, not for those converted directly to and from text.
*
* @param obj object being unmarshalled
*/
void pushObject(Object obj);
/**
* Pop unmarshalled object from stack.
*
* @throws JiBXException if stack empty
*/
void popObject() throws JiBXException;
/**
* Get current unmarshalling object stack depth. This allows tracking
* nested calls to unmarshal one object while in the process of
* unmarshalling another object. The bottom item on the stack is always the
* root object being unmarshalled.
*
* @return number of objects in unmarshalling stack
*/
int getStackDepth();
/**
* Get object from unmarshalling stack. This stack allows tracking nested
* calls to unmarshal one object while in the process of unmarshalling
* another object. The bottom item on the stack is always the root object
* being unmarshalled.
*
* @param depth object depth in stack to be retrieved (must be in the range
* of zero to the current depth minus one).
* @return object from unmarshalling stack
*/
Object getStackObject(int depth);
/**
* Get top object on unmarshalling stack. This is safe to call even when no
* objects are on the stack.
*
* @return object from unmarshalling stack, or null if none
*/
Object getStackTop();
} libjibx1.2-java-1.2.3/build/src/org/jibx/runtime/IXMLReader.java 0000644 0001750 0001750 00000021270 11177644430 024102 0 ustar twerner twerner /*
Copyright (c) 2005-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.runtime;
import java.io.IOException;
/**
* XML reader interface used for input of unmarshalled document. This interface
* allows easy substitution of different parsers or other input sources.
*
* @author Dennis M. Sosnoski
*/
public interface IXMLReader
{
//
// Event types reported by nextEvent() method
static final int START_DOCUMENT = 0;
static final int END_DOCUMENT = 1;
static final int START_TAG = 2;
static final int END_TAG = 3;
static final int TEXT = 4;
static final int CDSECT = 5;
static final int ENTITY_REF = 6;
static final int IGNORABLE_WHITESPACE = 7;
static final int PROCESSING_INSTRUCTION = 8;
static final int COMMENT = 9;
static final int DOCDECL = 10;
/**
* Initialize reader.
*
* @throws IOException
*/
void init() throws IOException;
/**
* Build current parse input position description.
*
* @return text description of current parse position
*/
String buildPositionString();
/**
* Advance to next parse event of input document.
*
* @return parse event type code
* @throws JiBXException if error reading or parsing document
*/
int nextToken() throws JiBXException;
/**
* Advance to next binding component of input document. This is a
* higher-level operation than {@link #nextToken()}, which consolidates text
* content and ignores parse events for components such as comments and PIs.
*
* @return parse event type code
* @throws JiBXException if error reading or parsing document
*/
int next() throws JiBXException;
/**
* Gets the current parse event type, without changing the current parse
* state.
*
* @return parse event type code
* @throws JiBXException if error parsing document
*/
int getEventType() throws JiBXException;
/**
* Get element name from the current start or end tag.
*
* @return local name if namespace handling enabled, full name if namespace
* handling disabled
* @throws IllegalStateException if not at a start or end tag (optional)
*/
String getName();
/**
* Get element namespace from the current start or end tag.
*
* @return namespace URI if namespace handling enabled and element is in a
* namespace, empty string otherwise
* @throws IllegalStateException if not at a start or end tag (optional)
*/
String getNamespace();
/**
* Get element prefix from the current start or end tag.
*
* @return prefix text (null if no prefix)
* @throws IllegalStateException if not at a start or end tag
*/
String getPrefix();
/**
* Get the number of attributes of the current start tag.
*
* @return number of attributes
* @throws IllegalStateException if not at a start tag (optional)
*/
int getAttributeCount();
/**
* Get an attribute name from the current start tag.
*
* @param index attribute index
* @return local name if namespace handling enabled, full name if namespace
* handling disabled
* @throws IllegalStateException if not at a start tag or invalid index
*/
String getAttributeName(int index);
/**
* Get an attribute namespace from the current start tag.
*
* @param index attribute index
* @return namespace URI if namespace handling enabled and attribute is in a
* namespace, empty string otherwise
* @throws IllegalStateException if not at a start tag or invalid index
*/
String getAttributeNamespace(int index);
/**
* Get an attribute prefix from the current start tag.
*
* @param index attribute index
* @return prefix for attribute (null if no prefix present)
* @throws IllegalStateException if not at a start tag or invalid index
*/
String getAttributePrefix(int index);
/**
* Get an attribute value from the current start tag.
*
* @param index attribute index
* @return value text
* @throws IllegalStateException if not at a start tag or invalid index
*/
String getAttributeValue(int index);
/**
* Get an attribute value from the current start tag.
*
* @param ns namespace URI for expected attribute (may be null
* or the empty string for the empty namespace)
* @param name attribute name expected
* @return attribute value text, or null if missing
* @throws IllegalStateException if not at a start tag
*/
String getAttributeValue(String ns, String name);
/**
* Get current text. When positioned on a TEXT event this returns the actual
* text; for CDSECT it returns the text inside the CDATA section; for
* COMMENT, DOCDECL, or PROCESSING_INSTRUCTION it returns the text inside
* the structure.
*
* @return text for current event
*/
String getText();
/**
* Get current element nesting depth. The returned depth always includes the
* current start or end tag (if positioned on a start or end tag).
*
* @return element nesting depth
*/
int getNestingDepth();
/**
* Get number of namespace declarations active at depth.
*
* @param depth element nesting depth
* @return number of namespaces active at depth
* @throws IllegalArgumentException if invalid depth
*/
int getNamespaceCount(int depth);
/**
* Get namespace URI.
*
* @param index declaration index
* @return namespace URI
* @throws IllegalArgumentException if invalid index
*/
String getNamespaceUri(int index);
/**
* Get namespace prefix.
*
* @param index declaration index
* @return namespace prefix, null if a default namespace
* @throws IllegalArgumentException if invalid index
*/
String getNamespacePrefix(int index);
/**
* Get document name.
*
* @return document name, null if not known
*/
String getDocumentName();
/**
* Get current source line number.
*
* @return line number from source document, -1 if line number
* information not available
*/
int getLineNumber();
/**
* Get current source column number.
*
* @return column number from source document, -1 if column
* number information not available
*/
int getColumnNumber();
/**
* Get namespace URI associated with prefix.
*
* @param prefix namespace prefix to be matched (null for
* default namespace)
* @return associated URI (null if prefix not defined)
*/
String getNamespace(String prefix);
/**
* Return the input encoding, if known. This is only valid after parsing of
* a document has been started.
*
* @return input encoding (null if unknown)
*/
String getInputEncoding();
/**
* Return namespace processing flag.
*
* @return namespace processing flag (true if namespaces are
* processed by reader, false if not)
*/
boolean isNamespaceAware();
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/ 0000755 0001750 0001750 00000000000 11526304016 020622 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/util/InsertionOrderedMap.java 0000644 0001750 0001750 00000014071 10651200424 025401 0 ustar twerner twerner /*
Copyright (c) 2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.util;
import java.util.AbstractCollection;
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
/**
* Map with keys iterated in insertion order. This is similar to the Java 1.4
* java.util.LinkedHashMap class, but compatible with earlier JVM versions. It
* also guarantees insertion ordering only for iterating through the key values,
* not for other iterations. This implementation is optimized for insert-only
* maps.
*/
public class InsertionOrderedMap implements Map
{
private final Map m_baseMap;
private final ArrayList m_insertList;
public InsertionOrderedMap() {
m_baseMap = new HashMap();
m_insertList = new ArrayList();
}
/* (non-Javadoc)
* @see java.util.Map#clear()
*/
public void clear() {
m_baseMap.clear();
m_insertList.clear();
}
/* (non-Javadoc)
* @see java.util.Map#containsKey(java.lang.Object)
*/
public boolean containsKey(Object key) {
return m_baseMap.containsKey(key);
}
/* (non-Javadoc)
* @see java.util.Map#containsValue(java.lang.Object)
*/
public boolean containsValue(Object value) {
return m_baseMap.containsValue(value);
}
/* (non-Javadoc)
* @see java.util.Map#entrySet()
*/
public Set entrySet() {
return m_baseMap.entrySet();
}
/* (non-Javadoc)
* @see java.util.Map#get(java.lang.Object)
*/
public Object get(Object key) {
return m_baseMap.get(key);
}
/* (non-Javadoc)
* @see java.util.Map#isEmpty()
*/
public boolean isEmpty() {
return m_baseMap.isEmpty();
}
/* (non-Javadoc)
* @see java.util.Map#keySet()
*/
public Set keySet() {
return new ListSet(m_insertList);
}
/* (non-Javadoc)
* @see java.util.Map#put(java.lang.Object, java.lang.Object)
*/
public Object put(Object key, Object value) {
if (!m_baseMap.containsKey(key)) {
m_insertList.add(key);
}
return m_baseMap.put(key, value);
}
/* (non-Javadoc)
* @see java.util.Map#putAll(java.util.Map)
*/
public void putAll(Map t) {
for (Iterator iter = t.entrySet().iterator(); iter.hasNext();) {
Entry entry = (Entry)iter.next();
put(entry.getKey(), entry.getValue());
}
}
/* (non-Javadoc)
* @see java.util.Map#remove(java.lang.Object)
*/
public Object remove(Object key) {
if (m_baseMap.containsKey(key)) {
m_insertList.remove(key);
return m_baseMap.remove(key);
} else {
return null;
}
}
/* (non-Javadoc)
* @see java.util.Map#size()
*/
public int size() {
return m_baseMap.size();
}
/* (non-Javadoc)
* @see java.util.Map#values()
*/
public Collection values() {
return new ValueCollection();
}
/**
* Get list of keys in order added. The returned list is live, and will
* grow or shrink as pairs are added to or removed from the map.
*
* @return key list
*/
public ArrayList keyList() {
return m_insertList;
}
/**
* Set implementation backed by a list.
*/
protected static class ListSet extends AbstractSet
{
private final List m_list;
public ListSet(List list) {
m_list = list;
}
public Iterator iterator() {
return m_list.iterator();
}
public int size() {
return m_list.size();
}
}
protected class ValueCollection extends AbstractCollection
{
public Iterator iterator() {
return new ValueIterator();
}
public int size() {
return m_insertList.size();
}
}
protected class ValueIterator implements Iterator
{
private int m_index = -1;
public boolean hasNext() {
return m_index < m_insertList.size()-1;
}
public Object next() {
if (m_index < m_insertList.size()-1) {
Object key = m_insertList.get(++m_index);
return m_baseMap.get(key);
} else {
throw new NoSuchElementException("Past end of list");
}
}
public void remove() {
throw new UnsupportedOperationException("Internal error - remove() not supported");
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/IClassItem.java 0000644 0001750 0001750 00000011305 11062041214 023453 0 ustar twerner twerner /*
Copyright (c) 2004-2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.util;
/**
* Interface for field or method information. Provides the information needed
* for access to the item.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public interface IClassItem
{
/**
* Get owning class information.
*
* @return owning class information
*/
public IClass getOwningClass();
/**
* Get item name.
*
* @return item name
*/
public String getName();
/**
* Get item JavaDoc description, if available.
*
* @return non-empty JavaDoc text (null if not available)
*/
public String getJavaDoc();
/**
* Get item type as fully qualified class name.
*
* @return item type name
*/
public String getTypeName();
/**
* Get return JavaDoc description for method, if available.
*
* @return non-empty JavaDoc text (null if not available)
*/
public String getReturnJavaDoc();
/**
* Get number of arguments for method.
*
* @return argument count for method, or -1 if not a method
*/
public int getArgumentCount();
/**
* Get argument type as fully qualified class name. This method will throw a
* runtime exception if called on a field.
*
* @param index argument number
* @return argument type name
*/
public String getArgumentType(int index);
/**
* Get method parameter name, if available. This method will throw a
* runtime exception if called on a field.
*
* @param index parameter number
* @return parameter name (null if not available)
*/
public String getParameterName(int index);
/**
* Get method parameter JavaDoc description, if available. This method will
* throw a runtime exception if called on a field.
*
* @param index parameter number
* @return non-empty JavaDoc text (null if not available)
*/
public String getParameterJavaDoc(int index);
/**
* Get access flags.
*
* @return flags for access type of field or method
*/
public int getAccessFlags();
/**
* Get field or method signature.
*
* @return encoded method signature
*/
public String getSignature();
/**
* Check if item is a method.
*
* @return true if a method, false if a field
*/
public boolean isMethod();
/**
* Check if item is an initializer.
*
* @return true if an initializer, false if a
* field or normal method
*/
public boolean isInitializer();
/**
* Get names of exceptions thrown by method.
*
* @return array of exceptions thrown by method, or null if
* a field
*/
public String[] getExceptions();
/**
* Get method throws JavaDoc description, if available. This method will
* throw a runtime exception if called on a field.
*
* @param index exception index (into array returned by
* {@link #getExceptions()}
* @return non-empty JavaDoc text (null if not available)
*/
public String getExceptionJavaDoc(int index);
/**
* Get the generics signature information for item.
*
* @return generics signature (null if none)
*/
public String getGenericsSignature();
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/DummyClassLocator.java 0000644 0001750 0001750 00000017135 11167464036 025113 0 ustar twerner twerner /*
Copyright (c) 2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.util;
import org.jibx.binding.classes.ClassFile;
/**
* Dummy class locator, used when no class information is available. This returns only place holder class information.
*
* @author Dennis M. Sosnoski
*/
public class DummyClassLocator implements IClassLocator
{
/** Singleton instance of root class information. */
private final IClass s_objectDummy = new DummyClassInfo("java.lang.Object", null);
/**
* Check if class lookup is supported. Always returns false to indicate that lookup methods return only
* place holder class information.
*
* @return false
*/
public boolean isLookupSupported() {
return false;
}
/**
* Get class information.
*
* @param name fully-qualified name of class to be found
* @return class information, or null if class not found
*/
public IClass getClassInfo(String name) {
return new DummyClassInfo(name, s_objectDummy);
}
/**
* Get required class information. This is just like {@link #getClassInfo(String)}, but throws a runtime exception
* rather than returning null.
*
* @param name fully-qualified name of class to be found
* @return class information (non-null)
*/
public IClass getRequiredClassInfo(String name) {
return new DummyClassInfo(name, s_objectDummy);
}
/**
* Load class. This just loads and returns the class, if it's available on the classpath.
*
* @param name fully-qualified class name
* @return loaded class, or null if not found
*/
public Class loadClass(String name) {
try {
return DummyClassLocator.class.getClassLoader().loadClass(name);
} catch (ClassNotFoundException e) {
return null;
}
}
/**
* (Very) partial implementation of class information interface, used as a place holder for classes.
*/
private class DummyClassInfo implements IClass
{
private final String m_name;
private final String m_package;
private final String m_signature;
private final IClass m_superclass;
public DummyClassInfo(String name, IClass sclas) {
m_name = name;
int split = name.lastIndexOf('.');
if (split < 0) {
m_package = "";
} else {
m_package = name.substring(0, split);
}
m_signature = "L" + name.replace('.', '\\') + ';';
m_superclass = sclas;
}
public IClassItem getBestMethod(String name, String type, String[] args) {
throw new IllegalStateException("Internal error - class information not available");
}
public ClassFile getClassFile() {
throw new IllegalStateException("Internal error - class information not available");
}
public IClassItem getDirectField(String name) {
throw new IllegalStateException("Internal error - class information not available");
}
public IClassItem getField(String name) {
throw new IllegalStateException("Internal error - class information not available");
}
public IClassItem[] getFields() {
throw new IllegalStateException("Internal error - class information not available");
}
public IClassItem getInitializerMethod(String sig) {
throw new IllegalStateException("Internal error - class information not available");
}
public String[] getInstanceSigs() {
throw new IllegalStateException("Internal error - class information not available");
}
public String[] getInterfaces() {
throw new IllegalStateException("Internal error - class information not available");
}
public String getJavaDoc() {
return null;
}
public IClassLocator getLocator() {
return DummyClassLocator.this;
}
public IClassItem getMethod(String name, String sig) {
throw new IllegalStateException("Internal error - class information not available");
}
public IClassItem getMethod(String name, String[] sigs) {
throw new IllegalStateException("Internal error - class information not available");
}
public IClassItem[] getMethods() {
throw new IllegalStateException("Internal error - class information not available");
}
public String getName() {
return m_name;
}
public String getPackage() {
return null;
}
public String getSignature() {
return null;
}
public IClassItem getStaticMethod(String name, String sig) {
throw new IllegalStateException("Internal error - class information not available");
}
public IClass getSuperClass() {
return m_superclass;
}
public boolean isAbstract() {
throw new IllegalStateException("Internal error - class information not available");
}
public boolean isAccessible(IClassItem item) {
throw new IllegalStateException("Internal error - class information not available");
}
public boolean isAssignable(IClass other) {
throw new IllegalStateException("Internal error - class information not available");
}
public boolean isImplements(String sig) {
throw new IllegalStateException("Internal error - class information not available");
}
public boolean isInterface() {
throw new IllegalStateException("Internal error - class information not available");
}
public boolean isModifiable() {
throw new IllegalStateException("Internal error - class information not available");
}
public boolean isSuperclass(String name) {
throw new IllegalStateException("Internal error - class information not available");
}
public Class loadClass() {
return DummyClassLocator.this.loadClass(m_name);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/ChainedMap.java 0000644 0001750 0001750 00000014142 11171721676 023473 0 ustar twerner twerner /*
* Copyright (c) 2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.util;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* Partial implementation of {@link java.util.Map} which provides a merged view of a defaults map with an overrides map.
* Although this can be used as a map for most purposes, methods which return live views of the keys or values in the
* map only take into account the overrides, not the defaults.
*/
public class ChainedMap implements Map
{
/** Default values map. */
private final Map m_defaults;
/** Override values map. */
private final Map m_overrides;
/**
* Constructor.
*
* @param defaults map providing defaults for keys not set directly
*/
public ChainedMap(Map defaults) {
m_defaults = defaults;
m_overrides = new HashMap();
}
/**
* Clear all override key-value pairs. This only effects the overrides, not the defaults.
*/
public void clear() {
m_defaults.clear();
}
/**
* Check if a key has a defined value. This will return true if the key is present in the overrides map
* with a non-null value, or if the key is not present in the overrides map but is present in the defaults map.
*
* @param key
* @return true if key defined, false if not
*/
public boolean containsKey(Object key) {
if (m_overrides.containsKey(key)) {
return m_overrides.get(key) != null;
} else {
return m_defaults.containsKey(key);
}
}
/**
* Check if a value is present. This only checks for the value in the overrides map.
*
* @param value
* @return true if value present as an override, false if not
*/
public boolean containsValue(Object value) {
return m_overrides.containsValue(value);
}
/**
* Get the set of entries. This only returns the entries in the overrides map.
*
* @return override entries
*/
public Set entrySet() {
return m_overrides.entrySet();
}
/**
* Get value for key. If the key is present in the overrides map, the value from that map is returned; otherwise,
* the value for the key in the defaults map is returned.
*
* @param key
* @return value (null if key not present)
*/
public Object get(Object key) {
if (m_overrides.containsKey(key)) {
return m_overrides.get(key);
} else {
return m_defaults.get(key);
}
}
/**
* Check if no overrides are defined.
*
* @return true if no overrides, false if any present
*/
public boolean isEmpty() {
return m_overrides.isEmpty();
}
/**
* Get the set of keys. This only returns the keys in the overrides map.
*
* @return keys
*/
public Set keySet() {
return m_overrides.keySet();
}
/**
* Set an override value. This just adds the key-value pair to the override map.
*
* @param key
* @param value
* @return previous value for key (from default map, if not present in overrides)
*/
public Object put(Object key, Object value) {
Object prior;
if (m_overrides.containsKey(key)) {
prior = m_overrides.put(key, value);
} else {
m_overrides.put(key, value);
prior = m_defaults.get(key);
}
return prior;
}
/**
* Add all key-value pairs from another map into the overrides map.
*
* @param map
*/
public void putAll(Map map) {
m_overrides.putAll(map);
}
/**
* Remove a key-value pair. If the key was previously present in the overrides map it is simply removed from that
* map. If it was not present in the overrides map but is present in the defaults map, a null entry is added to the
* overrides map for that key.
*
* @param key
* @return previous value for key
*/
public Object remove(Object key) {
if (m_overrides.containsKey(key)) {
return m_overrides.remove(key);
} else {
return m_defaults.remove(key);
}
}
/**
* Get the number of entries in the map. This returns the entry count for the overrides map only.
*
* @return entry count
*/
public int size() {
return m_overrides.size();
}
/**
* Get the values. This returns only the values in the overrides map.
*
* @return values
*/
public Collection values() {
return m_overrides.values();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/StringArray.java 0000644 0001750 0001750 00000020110 11505745302 023730 0 ustar twerner twerner /*
* Copyright (c) 2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.util;
/**
* Wrapper for arrays of ordered strings. This verifies the arrays and supports
* efficient lookups.
*
* @author Dennis M. Sosnoski
*/
public class StringArray
{
/** Empty array of strings. */
public static final StringArray EMPTY_ARRAY =
new StringArray(new String[0]);
/** Ordered array of strings. */
private final String[] m_list;
/**
* Constructor from array of values. This checks the array values to make
* sure they're ordered and unique, and if they're not throws an exception.
* Once the array has been passed to this constructor it must not be
* modified by outside code.
*
* @param list array of values
*/
public StringArray(String[] list) {
validateArray(list);
m_list = list;
}
/**
* Constructor from array of values to be added to base instance. This
* merges the array values, making sure they're ordered and unique, and if
* they're not throws an exception.
*
* @param list array of values
* @param base base instance
*/
public StringArray(String[] list, StringArray base) {
validateArray(list);
m_list = mergeArrays(list, base.m_list);
}
/**
* Constructor from pair of base instances. This merges the values, making
* sure they're unique, and if they're not throws an exception.
*
* @param array1 first base array
* @param array2 second base array
*/
public StringArray(StringArray array1, StringArray array2) {
m_list = mergeArrays(array1.m_list, array2.m_list);
}
/**
* Constructor from array of values to be added to pair of base instances.
* This merges the array values, making sure they're ordered and unique, and
* if they're not throws an exception.
*
* @param list array of values
* @param array1 first base array
* @param array2 second base array
*/
public StringArray(String[] list, StringArray array1, StringArray array2) {
validateArray(list);
m_list = mergeArrays(list, mergeArrays(array1.m_list, array2.m_list));
}
/**
* Constructor from array of values to be added to three base instances.
* This merges the array values, making sure they're ordered and unique, and
* if they're not throws an exception.
*
* @param list array of values
* @param array1 first base array
* @param array2 second base array
* @param array3 third base array
*/
public StringArray(String[] list, StringArray array1, StringArray array2,
StringArray array3) {
validateArray(list);
m_list = mergeArrays(list, mergeArrays(array1.m_list,
mergeArrays(array2.m_list, array3.m_list)));
}
/**
* Constructor from array of values to be added to four base instances.
* This merges the array values, making sure they're ordered and unique, and
* if they're not throws an exception.
*
* @param list array of values
* @param array1 first base array
* @param array2 second base array
* @param array3 third base array
* @param array4 fourth base array
*/
public StringArray(String[] list, StringArray array1, StringArray array2,
StringArray array3, StringArray array4) {
validateArray(list);
m_list = mergeArrays(list, mergeArrays(array1.m_list,
mergeArrays(array2.m_list,
mergeArrays(array3.m_list, array4.m_list))));
}
/**
* Merge a pair of ordered arrays into a single array. The two source arrays
* must not contain any values in common.
*
* @param list1 first ordered array
* @param list2 second ordered array
* @return merged array
*/
private String[] mergeArrays(String[] list1, String[] list2) {
String[] merge = new String[list1.length + list2.length];
int fill = 0;
int i = 0;
int j = 0;
while (i < list1.length && j < list2.length) {
int diff = list2[j].compareTo(list1[i]);
if (diff > 0) {
merge[fill++] = list1[i++];
} else if (diff < 0) {
merge[fill++] = list2[j++];
} else {
throw new IllegalArgumentException
("Repeated value not allowed: \"" + list1[i] + '"');
}
}
if (i < list1.length) {
System.arraycopy(list1, i, merge, fill, list1.length-i);
}
if (j < list2.length) {
System.arraycopy(list2, j, merge, fill, list2.length-j);
}
return merge;
}
/**
* Make sure passed-in array contains values that are in order and without
* duplicate values.
*
* @param list
*/
private void validateArray(String[] list) {
if (list.length > 0) {
String last = list[0];
int index = 0;
while (++index < list.length) {
String comp = list[index];
int diff = last.compareTo(comp);
if (diff > 0) {
throw new IllegalArgumentException
("Array values are not ordered");
} else if (diff < 0) {
last = comp;
} else {
throw new IllegalArgumentException
("Duplicate values in array");
}
}
}
}
/**
* Get string at a particular index in the list.
*
* @param index list index to be returned
* @return string at that index position
*/
public String get(int index) {
return m_list[index];
}
/**
* Find index of a particular string in the array. This does
* a binary search through the array values, using a pair of
* index bounds to track the subarray of possible matches at
* each iteration.
*
* @param value string to be found in list
* @return index of string in array, or -1 if
* not present
*/
public int indexOf(String value) {
int base = 0;
int limit = m_list.length - 1;
while (base <= limit) {
int cur = (base + limit) >> 1;
int diff = value.compareTo(m_list[cur]);
if (diff < 0) {
limit = cur - 1;
} else if (diff > 0) {
base = cur + 1;
} else {
return cur;
}
}
return -1;
}
/**
* Get number of values in array
*
* @return number of values in array
*/
public int size() {
return m_list.length;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/InsertionOrderedSet.java 0000644 0001750 0001750 00000012030 11212250066 025411 0 ustar twerner twerner /*
Copyright (c) 2007-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.util;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
/**
* Set with values iterated in insertion order. This is similar to the Java 1.4
* java.util.LinkedHashSet class, but compatible with earlier JVM versions. This
* implementation is for insert-only sets.
*/
public class InsertionOrderedSet implements Set
{
private final Set m_baseMap;
private final ArrayList m_insertList;
public InsertionOrderedSet() {
m_baseMap = new HashSet();
m_insertList = new ArrayList();
}
/* (non-Javadoc)
* @see java.util.Map#clear()
*/
public void clear() {
m_baseMap.clear();
m_insertList.clear();
}
/* (non-Javadoc)
* @see java.util.Set#isEmpty()
*/
public boolean isEmpty() {
return m_baseMap.isEmpty();
}
/* (non-Javadoc)
* @see java.util.Set#size()
*/
public int size() {
return m_baseMap.size();
}
/* (non-Javadoc)
* @see java.util.Set#add(java.lang.Object)
*/
public boolean add(Object o) {
if (m_baseMap.contains(o)) {
return false;
} else {
m_baseMap.add(o);
m_insertList.add(o);
return true;
}
}
/* (non-Javadoc)
* @see java.util.Set#addAll(java.util.Collection)
*/
public boolean addAll(Collection c) {
boolean changed = false;
for (Iterator iter = c.iterator(); iter.hasNext();) {
Object item = (Object)iter.next();
if (add(item)) {
changed = true;
}
}
return changed;
}
/* (non-Javadoc)
* @see java.util.Set#contains(java.lang.Object)
*/
public boolean contains(Object o) {
return m_baseMap.contains(o);
}
/* (non-Javadoc)
* @see java.util.Set#containsAll(java.util.Collection)
*/
public boolean containsAll(Collection c) {
return m_baseMap.containsAll(c);
}
/* (non-Javadoc)
* @see java.util.Set#iterator()
*/
public Iterator iterator() {
return m_insertList.iterator();
}
/* (non-Javadoc)
* @see java.util.Set#remove(java.lang.Object)
*/
public boolean remove(Object o) {
throw new UnsupportedOperationException("add-only set");
}
/* (non-Javadoc)
* @see java.util.Set#removeAll(java.util.Collection)
*/
public boolean removeAll(Collection c) {
throw new UnsupportedOperationException("add-only set");
}
/* (non-Javadoc)
* @see java.util.Set#retainAll(java.util.Collection)
*/
public boolean retainAll(Collection c) {
throw new UnsupportedOperationException("add-only set");
}
/* (non-Javadoc)
* @see java.util.Set#toArray()
*/
public Object[] toArray() {
return m_insertList.toArray();
}
/* (non-Javadoc)
* @see java.util.Set#toArray(T[])
*/
public Object[] toArray(Object[] a) {
return m_insertList.toArray(a);
}
/**
* Convenience method to add every item in an array.
*
* @param objs
*/
public void addAll(Object[] objs) {
for (int i = 0; i < objs.length; i++) {
add(objs[i]);
}
}
/**
* Get list of values in order added. The returned list is a static copy of
* the current list.
*
* @return list
*/
public List asList() {
return Collections.unmodifiableList(m_insertList);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/StringStack.java 0000644 0001750 0001750 00000023747 11062041224 023730 0 ustar twerner twerner /*
Copyright (c) 2000-2006, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.util;
import java.lang.reflect.Array;
/**
* Growable String stack with type specific access methods. This
* implementation is unsynchronized in order to provide the best possible
* performance for typical usage scenarios, so explicit synchronization must
* be implemented by a wrapper class or directly by the application in cases
* where instances are modified in a multithreaded environment.
*
* @author Dennis M. Sosnoski
*/
public class StringStack
{
/** Default initial array size. */
public static final int DEFAULT_SIZE = 8;
/** Size of the current array. */
private int m_countLimit;
/** The number of values currently present in the stack. */
private int m_countPresent;
/** Maximum size increment for growing array. */
private int m_maximumGrowth;
/** The underlying array used for storing the data. */
private String[] m_baseArray;
/**
* Constructor with full specification.
*
* @param size number of String values initially allowed in
* stack
* @param growth maximum size increment for growing stack
*/
public StringStack(int size, int growth) {
String[] array = new String[size];
m_countLimit = size;
m_maximumGrowth = growth;
m_baseArray = array;
}
/**
* Constructor with initial size specified.
*
* @param size number of String values initially allowed in
* stack
*/
public StringStack(int size) {
this(size, Integer.MAX_VALUE);
}
/**
* Default constructor.
*/
public StringStack() {
this(DEFAULT_SIZE);
}
/**
* Copy (clone) constructor.
*
* @param base instance being copied
*/
public StringStack(StringStack base) {
this(base.m_countLimit, base.m_maximumGrowth);
System.arraycopy(base.m_baseArray, 0, m_baseArray, 0,
base.m_countPresent);
m_countPresent = base.m_countPresent;
}
/**
* Constructor from array of strings.
*
* @param strings array of strings for initial contents
*/
public StringStack(String[] strings) {
this(strings.length);
System.arraycopy(strings, 0, m_baseArray, 0, strings.length);
m_countPresent = strings.length;
}
/**
* Copy data after array resize. This just copies the entire contents of the
* old array to the start of the new array. It should be overridden in cases
* where data needs to be rearranged in the array after a resize.
*
* @param base original array containing data
* @param grown resized array for data
*/
private void resizeCopy(Object base, Object grown) {
System.arraycopy(base, 0, grown, 0, Array.getLength(base));
}
/**
* Discards values for a range of indices in the array. Checks if the
* values stored in the array are object references, and if so clears
* them. If the values are primitives, this method does nothing.
*
* @param from index of first value to be discarded
* @param to index past last value to be discarded
*/
private void discardValues(int from, int to) {
for (int i = from; i < to; i++) {
m_baseArray[i] = null;
}
}
/**
* Increase the size of the array to at least a specified size. The array
* will normally be at least doubled in size, but if a maximum size
* increment was specified in the constructor and the value is less than
* the current size of the array, the maximum increment will be used
* instead. If the requested size requires more than the default growth,
* the requested size overrides the normal growth and determines the size
* of the replacement array.
*
* @param required new minimum size required
*/
private void growArray(int required) {
int size = Math.max(required,
m_countLimit + Math.min(m_countLimit, m_maximumGrowth));
String[] grown = new String[size];
resizeCopy(m_baseArray, grown);
m_countLimit = size;
m_baseArray = grown;
}
/**
* Ensure that the array has the capacity for at least the specified
* number of values.
*
* @param min minimum capacity to be guaranteed
*/
public final void ensureCapacity(int min) {
if (min > m_countLimit) {
growArray(min);
}
}
/**
* Push a value on the stack.
*
* @param value value to be added
*/
public void push(String value) {
int index = getAddIndex();
m_baseArray[index] = value;
}
/**
* Pop a value from the stack.
*
* @return value from top of stack
* @exception ArrayIndexOutOfBoundsException on attempt to pop empty stack
*/
public String pop() {
if (m_countPresent > 0) {
String value = m_baseArray[--m_countPresent];
m_baseArray[m_countPresent] = null;
return value;
} else {
throw new ArrayIndexOutOfBoundsException
("Attempt to pop empty stack");
}
}
/**
* Pop multiple values from the stack. The last value popped is the
* one returned.
*
* @param count number of values to pop from stack (must be strictly
* positive)
* @return value from top of stack
* @exception ArrayIndexOutOfBoundsException on attempt to pop past end of
* stack
*/
public String pop(int count) {
if (count < 0) {
throw new IllegalArgumentException("Count must be greater than 0");
} else if (m_countPresent >= count) {
m_countPresent -= count;
String value = m_baseArray[m_countPresent];
discardValues(m_countPresent, m_countPresent + count);
return value;
} else {
throw new ArrayIndexOutOfBoundsException
("Attempt to pop past end of stack");
}
}
/**
* Copy a value from the stack. This returns a value from within
* the stack without modifying the stack.
*
* @param depth depth of value to be returned
* @return value from stack
* @exception ArrayIndexOutOfBoundsException on attempt to peek past end of
* stack
*/
public String peek(int depth) {
if (m_countPresent > depth) {
return m_baseArray[m_countPresent - depth - 1];
} else {
throw new ArrayIndexOutOfBoundsException
("Attempt to peek past end of stack");
}
}
/**
* Copy top value from the stack. This returns the top value without
* removing it from the stack.
*
* @return value at top of stack
* @exception ArrayIndexOutOfBoundsException on attempt to peek empty stack
*/
public String peek() {
return peek(0);
}
/**
* Constructs and returns a simple array containing the same data as held
* in this stack. Note that the items will be in reverse pop order, with
* the last item to be popped from the stack as the first item in the
* array.
*
* @return array containing a copy of the data
*/
public String[] toArray() {
String[] copy = new String[m_countPresent];
System.arraycopy(m_baseArray, 0, copy, 0, m_countPresent);
return copy;
}
/**
* Duplicates the object with the generic call.
*
* @return a copy of the object
*/
public Object clone() {
return new StringStack(this);
}
/**
* Gets the array offset for appending a value to those in the stack.
* If the underlying array is full, it is grown by the appropriate size
* increment so that the index value returned is always valid for the
* array in use by the time of the return.
*
* @return index position for added element
*/
private int getAddIndex() {
int index = m_countPresent++;
if (m_countPresent > m_countLimit) {
growArray(m_countPresent);
}
return index;
}
/**
* Get the number of values currently present in the stack.
*
* @return count of values present
*/
public int size() {
return m_countPresent;
}
/**
* Check if stack is empty.
*
* @return true if stack empty, false if not
*/
public boolean isEmpty() {
return m_countPresent == 0;
}
/**
* Set the stack to the empty state.
*/
public void clear() {
discardValues(0, m_countPresent);
m_countPresent = 0;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/IClassLocator.java 0000644 0001750 0001750 00000005417 11167464036 024210 0 ustar twerner twerner /*
Copyright (c) 2004-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.util;
/**
* Locator for class information. Looks up classes using whatever method is
* appropriate for the usage environment.
*
* @author Dennis M. Sosnoski
*/
public interface IClassLocator
{
/**
* Check if class lookup is supported. If this returns false,
* lookup methods return only place holder class information.
*
* @return true if class lookup supported, false
* if only place holder information returned
*/
boolean isLookupSupported();
/**
* Get class information.
*
* @param name fully-qualified name of class to be found
* @return class information, or null if class not found
*/
IClass getClassInfo(String name);
/**
* Get required class information. This is just like {@link
* #getClassInfo(String)}, but throws a runtime exception rather than
* returning null.
*
* @param name fully-qualified name of class to be found
* @return class information (non-null)
*/
IClass getRequiredClassInfo(String name);
/**
* Load class.
*
* @param name fully-qualified class name
* @return loaded class, or null if not found
*/
Class loadClass(String name);
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/UniqueNameSet.java 0000644 0001750 0001750 00000010666 11323625144 024224 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.util;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
* Set of unique names for a context. This assures uniqueness as names are added to the set.
*
* @author Dennis M. Sosnoski
*/
public class UniqueNameSet
{
/** Set of names used. */
private final Set m_nameSet;
/**
* Constructor.
*/
public UniqueNameSet() {
m_nameSet = new HashSet();
}
/**
* Constructor from existing name collection. Creates a name set initialized to contain all the supplied names.
*
* @param base
*/
public UniqueNameSet(Collection base) {
m_nameSet = new HashSet(base);
}
/**
* Copy constructor. Creates a name set initialized to contain all the names from another name set.
*
* @param original
*/
public UniqueNameSet(UniqueNameSet original) {
this();
addAll(original);
}
/**
* Check if a name is already present in context.
*
* @param name
* @return true if present, false if not
*/
public boolean contains(String name) {
return m_nameSet.contains(name);
}
/**
* Add all the names from another name set to this set. This does not check for conflicts between the names in the
* two sets.
*
* @param other
*/
public void addAll(UniqueNameSet other) {
m_nameSet.addAll(other.m_nameSet);
}
/**
* Add name to set. If the supplied name is already present, it is modified by appending a variable suffix. If the
* supplied name ends with a digit, the suffix is generated starting with the letter 'a'; otherwise, it's generated
* starting at '1'. Either way, the suffix is incremented as many times as necessary to obtain a unique name.
*
* @param base name to try adding
* @return assigned name
*/
public String add(String base) {
String name = base;
int index = 1;
boolean usealpha = base.length() > 0 && Character.isDigit(base.charAt(base.length()-1));
while (m_nameSet.contains(name)) {
if (usealpha) {
String suffix = "";
int value = index++ - 1;
do {
int modulo = value % 52;
if (modulo > 26) {
suffix = (char)('A' + modulo - 26) + suffix;
} else {
suffix = (char)('a' + modulo) + suffix;
}
value /= 52;
} while (value > 0);
name = base + suffix;
} else {
name = base + index++;
}
}
m_nameSet.add(name);
return name;
}
/**
* Get iterator for names in set.
*
* @return iterator
*/
public Iterator iterator() {
return m_nameSet.iterator();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/ReflectionUtilities.java 0000644 0001750 0001750 00000027066 11254006516 025470 0 ustar twerner twerner /*
* Copyright (c) 2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.util;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.Utility;
/**
* Support methods for using reflection access to values.
*/
public class ReflectionUtilities
{
/**
* Apply a key/value map to an object instance. This uses reflection to match the keys to either set methods (with
* names of the form setZZZText taking a single String parameter, or setZZZ taking a single String or primitive
* wrapper parameter) or fields (named m_ZZZ). The ZZZ in the names is based on the key name, with hyphenation
* converted to camel case (leading upper camel case, for the method names).
*
* @param map
* @param obj
* @return map for key/values not found in the supplied object
*/
public static Map applyKeyValueMap(Map map, Object obj) {
Map missmap = new HashMap();
for (Iterator iter = map.keySet().iterator(); iter.hasNext();) {
String key = (String)iter.next();
Object value = map.get(key);
boolean fail = true;
Throwable t = null;
try {
// convert key to field and method name, and to alternate method name (used for value sets)
StringBuffer buff = new StringBuffer(key);
for (int i = 0; i < buff.length(); i++) {
char chr = buff.charAt(i);
if (chr == '-') {
buff.deleteCharAt(i);
buff.setCharAt(i, Character.toUpperCase(buff.charAt(i)));
}
}
String fname = "m_" + buff.toString();
buff.setCharAt(0, Character.toUpperCase(buff.charAt(0)));
String mname = "set" + buff.toString();
String altname = mname + "Text";
// first try to find a match for alternate method name, with text value and possibly unmarshaller
Method method = null;
Field field = null;
String tname = null;
Class clas = obj.getClass();
outer: while (!clas.getName().equals("java.lang.Object")) {
Method[] methods = clas.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
Method match = methods[i];
if (altname.equals(match.getName())) {
Class[] types = match.getParameterTypes();
if (types.length == 1 || (types.length == 2 && types[1] == IUnmarshallingContext.class)) {
if (types[0] == String.class) {
tname = String.class.getName();
try {
match.setAccessible(true);
} catch (SecurityException e) { /* deliberately empty */
}
method = match;
break outer;
}
}
}
}
clas = clas.getSuperclass();
}
if (method == null) {
// no match on alternate method name, next check for regular method
clas = obj.getClass();
outer: while (!clas.getName().equals("java.lang.Object")) {
Method[] methods = clas.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
Method match = methods[i];
if (mname.equals(match.getName())) {
Class[] types = match.getParameterTypes();
if (types.length == 1) {
tname = types[0].getName();
try {
match.setAccessible(true);
} catch (SecurityException e) { /* deliberately empty */
}
method = match;
break outer;
}
}
}
clas = clas.getSuperclass();
}
if (method == null) {
// still no match, finally try to find as a field
clas = obj.getClass();
while (!clas.getName().equals("java.lang.Object")) {
try {
field = clas.getDeclaredField(fname);
try {
field.setAccessible(true);
} catch (SecurityException e) { /* deliberately empty */
}
tname = field.getType().getName();
break;
} catch (NoSuchFieldException e) {
clas = clas.getSuperclass();
}
}
if (field == null) {
throw new IllegalArgumentException("Parameter " + key + " not found");
}
}
}
if ("boolean".equals(tname) || "java.lang.Boolean".equals(tname)) {
// convert text to boolean value
if ("true".equals(value) || "1".equals(value)) {
value = Boolean.TRUE;
} else if ("false".equals(value) || "0".equals(value)) {
value = Boolean.FALSE;
} else {
throw new IllegalArgumentException("Unknown value '" + value
+ "' for boolean parameter " + key);
}
} else if ("[Ljava.lang.String;".equals(tname)) {
// deserialize token list to string array
try {
value = org.jibx.runtime.Utility.deserializeTokenList((String)value);
} catch (JiBXException e) {
throw new IllegalArgumentException("Error processing list value + '" + value +
"': " + e.getMessage());
}
} else if ("int".equals(tname) || "java.lang.Integer".equals(tname)) {
// convert text to int value
try {
value = new Integer(Utility.parseInt((String)value));
} catch (JiBXException e) {
throw new IllegalArgumentException("Error processing int value + '" + value +
"': " + e.getMessage());
}
} else if ("long".equals(tname) || "java.lang.Long".equals(tname)) {
// convert text to long value
try {
value = new Long(Utility.parseLong((String)value));
} catch (JiBXException e) {
throw new IllegalArgumentException("Error processing long value + '" + value +
"': " + e.getMessage());
}
} else if ("float".equals(tname) || "java.lang.Float".equals(tname)) {
// convert text to float value
try {
value = new Float(Utility.parseFloat((String)value));
} catch (JiBXException e) {
throw new IllegalArgumentException("Error processing float value + '" + value +
"': " + e.getMessage());
}
} else if ("double".equals(tname) || "java.lang.Double".equals(tname)) {
// convert text to float value
try {
value = new Double(Utility.parseDouble((String)value));
} catch (JiBXException e) {
throw new IllegalArgumentException("Error processing double value + '" + value +
"': " + e.getMessage());
}
} else if (!"java.lang.String".equals(tname)) {
throw new IllegalArgumentException("Cannot handle value of type " + tname);
}
if (method != null) {
// set value using method
if (method.getParameterTypes().length == 1) {
method.invoke(obj, new Object[] { value });
} else {
method.invoke(obj, new Object[] { value, null });
}
} else {
// set value using field
field.set(obj, value);
}
fail = false;
} catch (IllegalAccessException e) {
t = e;
} catch (SecurityException e) {
t = e;
} catch (InvocationTargetException e) {
t = e;
} finally {
if (t != null) {
throw new IllegalArgumentException(t.getMessage());
}
}
if (fail) {
missmap.put(key, value);
}
}
return missmap;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/ClasspathUrlExtender.java 0000644 0001750 0001750 00000011310 11321372102 025557 0 ustar twerner twerner /*
* Copyright (c) 2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.util;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLStreamHandler;
/**
* Support class for accessing resources using classpath URLs. The {@link #buildURL(URL, String)} method must be used to
* construct a URL for a resource on the classpath, and the {@link #setClassLoader(ClassLoader)} method must first be
* used to set the classloader if it differs from the classloader used for loading this class.
*/
public class ClasspathUrlExtender
{
/** Protocol name for classpath access. */
public static final String CLASSPATH_PROTOCOL = "classpath";
/** Singleton instance of handler for stream access to resource. */
private static ClasspathHandler s_handler;
/**
* Set the classloader to be used for accessing resources.
*
* @param loader
*/
public static void setClassLoader(ClassLoader loader) {
s_handler = new ClasspathHandler(loader);
}
/**
* Check if a URL string represents a resource from the classpath.
*
* @param url
* @return true if classpath resource, false if not
*/
public static boolean isClasspathUrl(String url) {
return url.toLowerCase().startsWith(CLASSPATH_PROTOCOL);
}
/**
* Construct a URL which may represent a resource from the classpath.
*
* @param base URL base for relative references
* @param path resource path
* @return URL for access to resource
* @throws MalformedURLException if not a valid URL format
*/
public static URL buildURL(URL base, String path) throws MalformedURLException {
if (s_handler == null) {
s_handler = new ClasspathHandler(ClasspathUrlExtender.class.getClassLoader());
}
if (path.toLowerCase().startsWith(CLASSPATH_PROTOCOL + ":")) {
return new URL(null, path, s_handler);
} else if (base != null && CLASSPATH_PROTOCOL.equals(base.getProtocol())) {
return new URL(base, path, s_handler);
} else {
return new URL(base, path);
}
}
/**
* Handler for opening a connection to a resource from the classpath.
*/
public static class ClasspathHandler extends URLStreamHandler
{
/** The classloader to use for finding resources. */
private final ClassLoader m_loader;
/**
* Constructor.
*
* @param loader classloader used to find resources
*/
public ClasspathHandler(ClassLoader loader) {
m_loader = loader;
}
/* (non-Javadoc)
* @see java.net.URLStreamHandler#openConnection(java.net.URL)
*/
protected URLConnection openConnection(URL url) throws IOException {
String path = url.getPath();
if (path.startsWith("/")) {
path = path.substring(1);
}
URL alturl = m_loader.getResource(path);
if (alturl == null) {
throw new IOException("Classpath resource not found with path '" + path + '\'');
} else {
return alturl.openConnection();
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/ResourceMatcher.java 0000644 0001750 0001750 00000016161 11336052550 024567 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.util;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.log4j.Logger;
/**
* Supports finding resources relative to a file system base directory or base URL. When using a file system base
* directory, the resource paths may include '*' wildcard match characters for the actual file names.
*
* @author Dennis M. Sosnoski
*/
public class ResourceMatcher
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(ResourceMatcher.class.getName());
/**
* Find matches to resource paths. The paths may be either absolute, or relative to a file system directory or to a
* general URL, but the paths may contain '*' wildcard match characters only if relative to a file system directory.
* An error is reported for each invalid pattern, including wildcard patterns with no matching files and malformed
* URLs.
*
* @param basedir file system base directory (null if not using file system)
* @param baseurl base URL for names (null if no base)
* @param paths resource paths to be found, with wildcards allowed in name portion if using file system
* @param report match reporting interface
* @return error message list (empty list if no errors)
* @throws IOException
*/
public static List matchPaths(File basedir, URL baseurl, List paths, ReportMatch report)
throws IOException {
PatternMatcher filter = new PatternMatcher();
List errors = new ArrayList();
for (Iterator iter = paths.iterator(); iter.hasNext();) {
String path = (String)iter.next();
int wildstart = path.indexOf('*');
if (wildstart >= 0) {
if (basedir == null) {
errors.add("File name pattern argument not allowed for non-file base: '" + path + '\'');
} else {
File dir = basedir.getCanonicalFile();
if (File.separatorChar != '/') {
path = path.replace('/', File.separatorChar);
}
int split = path.lastIndexOf(File.separatorChar);
String pattern = path;
if (split >= 0) {
if (wildstart < split) {
errors.add("Wildcard can only be used for file name, not in the directory path, for pattern '" + path + '\'');
continue;
} else {
String dirpath = path.substring(0, split);
dir = new File(dirpath);
if (!dir.isAbsolute()) {
dir = new File(basedir, dirpath);
}
dir = dir.getCanonicalFile();
pattern = path.substring(split+1);
}
}
filter.setPattern(pattern);
s_logger.debug("Matching file names to command line pattern '" + path + '\'');
String[] matches = dir.list(filter);
if (matches == null || matches.length == 0) {
errors.add("No files found matching command line pattern '" + pattern +
"' in directory " + dir.getAbsolutePath());
} else {
for (int i = 0; i < matches.length; i++) {
String match = matches[i];
report.foundMatch(match, new URL(dir.toURI().toURL(), match));
}
}
}
} else {
// first try for a file, if base directory supplied
if (basedir != null) {
File file = new File(path);
if (!file.isAbsolute()) {
file = new File(basedir, path);
}
if (file.exists()) {
report.foundMatch(path, file.toURI().toURL());
continue;
}
}
// build URL, with support for classpath protocol
URL url = ClasspathUrlExtender.buildURL(baseurl, path);
report.foundMatch(path, url);
}
}
return errors;
}
/**
* Report matches found to name patterns.
*/
public interface ReportMatch
{
/**
* Match found for pattern.
*
* @param path
* @param url
*/
void foundMatch(String path, URL url);
}
/**
* File name pattern matcher.
*/
private static class PatternMatcher implements FilenameFilter
{
/** Current match pattern. */
private String m_pattern;
/**
* Set the match pattern.
*
* @param pattern
*/
public void setPattern(String pattern) {
m_pattern = pattern;
}
/**
* Check for file name match.
*
* @param dir
* @param name
* @return match flag
*/
public boolean accept(File dir, String name) {
boolean match = NameUtilities.isPatternMatch(name, m_pattern);
if (match) {
s_logger.debug(" matched file name '" + name + '\'');
}
return match;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/ReferenceCountMap.java 0000644 0001750 0001750 00000032014 11062041226 025026 0 ustar twerner twerner /*
* Copyright (c) 2006-2007, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.util;
import java.util.Iterator;
/**
* Hash map for counting references to Object keys. The map implementation is not very efficient when
* resizing, but works well when the size of the map is known in advance or when accesses are substantially more common
* than adds.
*
* @author Dennis M. Sosnoski
*/
public class ReferenceCountMap
{
/** Default fill fraction allowed before growing table. */
private static final double DEFAULT_FILL = 0.3d;
/** Minimum size used for hash table. */
private static final int MINIMUM_SIZE = 63;
/** Number of entries present in table. */
private int m_entryCount;
/** Entries allowed before growing table. */
private int m_entryLimit;
/** Size of array used for keys. */
private int m_arraySize;
/** Offset added (modulo table size) to slot number on collision. */
private int m_hitOffset;
/** Array of key table slots. */
private Object[] m_keyTable;
/** Array of value table slots. */
private int[] m_valueTable;
/**
* Constructor with count.
*
* @param count number of values to assume in initial sizing of table
*/
public ReferenceCountMap(int count) {
// compute initial table size (ensuring odd)
m_arraySize = Math.max((int)(count / DEFAULT_FILL), MINIMUM_SIZE);
m_arraySize += (m_arraySize + 1) % 2;
// initialize the table information
m_entryLimit = (int)(m_arraySize * DEFAULT_FILL);
m_hitOffset = m_arraySize / 2;
m_keyTable = new Object[m_arraySize];
m_valueTable = new int[m_arraySize];
}
/**
* Default constructor.
*/
public ReferenceCountMap() {
this(0);
}
/**
* Copy (clone) constructor.
*
* @param base instance being copied
*/
public ReferenceCountMap(ReferenceCountMap base) {
// copy the basic occupancy information
m_entryCount = base.m_entryCount;
m_entryLimit = base.m_entryLimit;
m_arraySize = base.m_arraySize;
m_hitOffset = base.m_hitOffset;
// copy table of items
m_keyTable = new Object[m_arraySize];
System.arraycopy(base.m_keyTable, 0, m_keyTable, 0, m_arraySize);
m_valueTable = new int[m_arraySize];
System.arraycopy(base.m_valueTable, 0, m_valueTable, 0, m_arraySize);
}
/**
* Step the slot number for an entry. Adds the collision offset (modulo the table size) to the slot number.
*
* @param slot slot number to be stepped
* @return stepped slot number
*/
private final int stepSlot(int slot) {
return (slot + m_hitOffset) % m_arraySize;
}
/**
* Find free slot number for entry. Starts at the slot based directly on the hashed key value. If this slot is
* already occupied, it adds the collision offset (modulo the table size) to the slot number and checks that slot,
* repeating until an unused slot is found.
*
* @param slot initial slot computed from key
* @return slot at which entry was added
*/
private final int freeSlot(int slot) {
while (m_keyTable[slot] != null) {
slot = stepSlot(slot);
}
return slot;
}
/**
* Standard base slot computation for a key.
*
* @param key key value to be computed
* @return base slot for key
*/
private final int standardSlot(Object key) {
return (key.hashCode() & Integer.MAX_VALUE) % m_arraySize;
}
/**
* Standard find key in table. This method may be used directly for key lookup using either the
* hashCode() method defined for the key objects or the System.identityHashCode()
* method, and either the equals() method defined for the key objects or the ==
* operator, as selected by the hash technique constructor parameter. To implement a hash class based on some other
* methods of hashing and/or equality testing, define a separate method in the subclass with a different name and
* use that method instead. This avoids the overhead caused by overrides of a very heavily used method.
*
* @param key to be found in table
* @return index of matching key, or -index-1 of slot to be used for inserting key in table if not
* already present (always negative)
*/
private int standardFind(Object key) {
// find the starting point for searching table
int slot = standardSlot(key);
// scan through table to find target key
while (m_keyTable[slot] != null) {
// check if we have a match on target key
if (m_keyTable[slot].equals(key)) {
return slot;
} else {
slot = stepSlot(slot);
}
}
return -slot - 1;
}
/**
* Reinsert an entry into the hash map. This is used when the table is being directly modified, and does not adjust
* the count present or check the table capacity.
*
* @param slot position of entry to be reinserted into hash map
* @return true if the slot number used by the entry has has changed, false if not
*/
private boolean reinsert(int slot) {
Object key = m_keyTable[slot];
m_keyTable[slot] = null;
return assignSlot(key, m_valueTable[slot]) != slot;
}
/**
* Internal remove pair from the table. Removes the pair from the table by setting the key entry to
* null and adjusting the count present, then chains through the table to reinsert any other pairs
* which may have collided with the removed pair. If the associated value is an object reference, it should be set
* to null before this method is called.
*
* @param slot index number of pair to be removed
*/
private void internalRemove(int slot) {
// delete pair from table
m_keyTable[slot] = null;
m_entryCount--;
while (m_keyTable[(slot = stepSlot(slot))] != null) {
// reinsert current entry in table to fill holes
reinsert(slot);
}
}
/**
* Restructure the table. This is used when the table is increasing or decreasing in size, and works directly with
* the old table representation arrays. It inserts pairs from the old arrays directly into the table without
* adjusting the count present or checking the table size.
*
* @param keys array of keys
* @param values array of values
*/
private void restructure(Object[] keys, int[] values) {
for (int i = 0; i < keys.length; i++) {
if (keys[i] != null) {
assignSlot(keys[i], values[i]);
}
}
}
/**
* Assign slot for entry. Starts at the slot found by the hashed key value. If this slot is already occupied, it
* steps the slot number and checks the resulting slot, repeating until an unused slot is found. This method does
* not check for duplicate keys, so it should only be used for internal reordering of the tables.
*
* @param key to be added to table
* @param value associated value for key
* @return slot at which entry was added
*/
private int assignSlot(Object key, int value) {
int offset = freeSlot(standardSlot(key));
m_keyTable[offset] = key;
m_valueTable[offset] = value;
return offset;
}
/**
* Increment a use count in the table. If the key object is already present in the table this adds one to the
* reference count; if not present, this adds the key with an initial reference count of one.
*
* @param key referenced object (non-null)
* @return incremented use count
*/
public int incrementCount(Object key) {
// first validate the parameters
if (key == null) {
throw new IllegalArgumentException("null key not supported");
} else {
// check space available
int min = m_entryCount + 1;
if (min > m_entryLimit) {
// find the array size required
int size = m_arraySize;
int limit = m_entryLimit;
while (limit < min) {
size = size * 2 + 1;
limit = (int)(size * DEFAULT_FILL);
}
// set parameters for new array size
m_arraySize = size;
m_entryLimit = limit;
m_hitOffset = size / 2;
// restructure for larger arrays
Object[] keys = m_keyTable;
m_keyTable = new Object[m_arraySize];
int[] values = m_valueTable;
m_valueTable = new int[m_arraySize];
restructure(keys, values);
}
// find slot of table
int offset = standardFind(key);
if (offset >= 0) {
// replace existing value for key
return ++m_valueTable[offset];
} else {
// add new pair to table
m_entryCount++;
offset = -offset - 1;
m_keyTable[offset] = key;
m_valueTable[offset] = 1;
return 1;
}
}
}
/**
* Find an entry in the table.
*
* @param key key for entry to be returned
* @return value for key, or zero if key not found
*/
public final int getCount(Object key) {
int slot = standardFind(key);
if (slot >= 0) {
return m_valueTable[slot];
} else {
return 0;
}
}
/**
* Get number of entries in map.
*
* @return entry count
*/
public int size() {
return m_entryCount;
}
/**
* Get iterator for keys in map. The returned iterator is not safe, so the iterator behavior is undefined if the map
* is modified.
*
* @return iterator
*/
public Iterator iterator() {
return SparseArrayIterator.buildIterator(m_keyTable);
}
/**
* Get array of keys in map.
*
* @return key array
*/
public Object[] keyArray() {
Object[] keys = new Object[m_entryCount];
int fill = 0;
for (int i = 0; i < m_arraySize; i++) {
if (m_keyTable[i] != null) {
keys[fill++] = m_keyTable[i];
}
}
return keys;
}
/**
* Construct a copy of the table.
*
* @return shallow copy of table
*/
public Object clone() {
return new ReferenceCountMap(this);
}
/**
* Clear all keys and counts.
*/
public void clear() {
for (int i = 0; i < m_keyTable.length; i++) {
if (m_keyTable[i] != null) {
m_keyTable[i] = null;
m_valueTable[i] = 0;
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/Types.java 0000644 0001750 0001750 00000012422 11261753040 022573 0 ustar twerner twerner /*
Copyright (c) 2007-2009, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.util;
import java.util.HashMap;
import org.jibx.runtime.QName;
/**
* Mapping information to and from schema types.
*/
public class Types
{
public static final String SCHEMA_NAMESPACE = "http://www.w3.org/2001/XMLSchema";
public static final QName STRING_QNAME = new QName(SCHEMA_NAMESPACE, "string");
/** Set of object types mapped to schema types. */
private static HashMap s_objectTypeMap = new HashMap();
static {
s_objectTypeMap.put("java.lang.Boolean", new QName(SCHEMA_NAMESPACE, "boolean"));
s_objectTypeMap.put("java.lang.Byte", new QName(SCHEMA_NAMESPACE, "byte"));
s_objectTypeMap.put("java.lang.Character", new QName(SCHEMA_NAMESPACE, "unsignedInt"));
s_objectTypeMap.put("java.lang.Double", new QName(SCHEMA_NAMESPACE, "double"));
s_objectTypeMap.put("java.lang.Float", new QName(SCHEMA_NAMESPACE, "float"));
s_objectTypeMap.put("java.lang.Integer", new QName(SCHEMA_NAMESPACE, "int"));
s_objectTypeMap.put("java.lang.Long", new QName(SCHEMA_NAMESPACE, "long"));
s_objectTypeMap.put("java.lang.Short", new QName(SCHEMA_NAMESPACE, "short"));
s_objectTypeMap.put("java.lang.String", STRING_QNAME);
s_objectTypeMap.put("java.math.BigDecimal", new QName(SCHEMA_NAMESPACE, "decimal"));
s_objectTypeMap.put("java.math.BigInteger", new QName(SCHEMA_NAMESPACE, "integer"));
s_objectTypeMap.put("java.util.Date", new QName(SCHEMA_NAMESPACE, "dateTime"));
//#!j2me{
s_objectTypeMap.put("java.sql.Date", new QName(SCHEMA_NAMESPACE, "date"));
s_objectTypeMap.put("java.sql.Time", new QName(SCHEMA_NAMESPACE, "time"));
s_objectTypeMap.put("java.sql.Timestamp", new QName(SCHEMA_NAMESPACE, "dateTime"));
s_objectTypeMap.put("org.joda.time.LocalDate", new QName(SCHEMA_NAMESPACE, "date"));
s_objectTypeMap.put("org.joda.time.DateMidnight", new QName(SCHEMA_NAMESPACE, "date"));
s_objectTypeMap.put("org.joda.time.LocalTime", new QName(SCHEMA_NAMESPACE, "time"));
s_objectTypeMap.put("org.joda.time.DateTime", new QName(SCHEMA_NAMESPACE, "dateTime"));
//#j2me}
s_objectTypeMap.put("byte[]", new QName(SCHEMA_NAMESPACE, "base64"));
s_objectTypeMap.put("org.jibx.runtime.QName", new QName(SCHEMA_NAMESPACE, "QName"));
}
/** Set of primitive types mapped to schema types. */
private static HashMap s_primitiveTypeMap = new HashMap();
static {
s_primitiveTypeMap.put("boolean", new QName(SCHEMA_NAMESPACE, "boolean"));
s_primitiveTypeMap.put("byte", new QName(SCHEMA_NAMESPACE, "byte"));
s_primitiveTypeMap.put("char", new QName(SCHEMA_NAMESPACE, "unsignedInt"));
s_primitiveTypeMap.put("double", new QName(SCHEMA_NAMESPACE, "double"));
s_primitiveTypeMap.put("float", new QName(SCHEMA_NAMESPACE, "float"));
s_primitiveTypeMap.put("int", new QName(SCHEMA_NAMESPACE, "int"));
s_primitiveTypeMap.put("long", new QName(SCHEMA_NAMESPACE, "long"));
s_primitiveTypeMap.put("short", new QName(SCHEMA_NAMESPACE, "short"));
}
/**
* Check if type represents a simple text value.
*
* @param type primitive type name, or fully qualified class name
* @return simple value flag
*/
public static boolean isSimpleValue(String type) {
return s_primitiveTypeMap.containsKey(type) ||
s_objectTypeMap.containsKey(type) || "void".equals(type);
}
/**
* Get the schema type for a simple text value.
*
* @param type primitive type name, or fully qualified class name
* @return schema type
*/
public static QName schemaType(String type) {
QName stype = (QName)s_primitiveTypeMap.get(type);
if (stype == null) {
stype = (QName)s_objectTypeMap.get(type);
}
return stype;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/NameUtilities.java 0000644 0001750 0001750 00000013205 11365563446 024261 0 ustar twerner twerner /*
* Copyright (c) 2008-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.util;
/**
* Support methods for name conversions.
*/
public class NameUtilities
{
/**
* Convert potentially plural name to singular form. TODO: internationalization?
*
* @param name base name
* @return singularized name
*/
public static String depluralize(String name) {
if (name.endsWith("ies")) {
return name.substring(0, name.length() - 3) + 'y';
} else if (name.endsWith("sses")) {
return name.substring(0, name.length() - 2);
} else if (name.endsWith("s") && !name.endsWith("ss")) {
return name.substring(0, name.length() - 1);
} else if (name.endsWith("List")) {
return name.substring(0, name.length() - 4);
} else {
return name;
}
}
/**
* Convert singular name to plural form. TODO: internationalization?
*
* @param name base name
* @return plural name
*/
public static String pluralize(String name) {
// first check for already in plural form
if (name.endsWith("List") || (name.endsWith("s") && !name.endsWith("ss"))) {
return name;
}
// convert singular form to plural
if (name.endsWith("y") && !name.endsWith("ay") && !name.endsWith("ey") && !name.endsWith("iy") &&
!name.endsWith("oy") && !name.endsWith("uy")) {
if (name.equalsIgnoreCase("any")) {
return name;
} else {
return name.substring(0, name.length() - 1) + "ies";
}
} else if (name.endsWith("ss")) {
return name + "es";
} else {
return name + 's';
}
}
/**
* Checks if a name matches a pattern. This method accepts one or more '*' wildcard
* characters in the pattern, calling itself recursively in order to handle multiple wildcards.
*
* @param name
* @param pattern match pattern
* @return true if pattern matched, false if not
*/
public static boolean isPatternMatch(String name, String pattern) {
// check special match cases first
if (pattern.length() == 0) {
return name.length() == 0;
} else if (pattern.charAt(0) == '*') {
// check if the wildcard is all that's left of pattern
if (pattern.length() == 1) {
return true;
} else {
// check if another wildcard follows next segment of text
pattern = pattern.substring(1);
int split = pattern.indexOf('*');
if (split > 0) {
// recurse on each match to text segment
String piece = pattern.substring(0, split);
pattern = pattern.substring(split);
int offset = -1;
while ((offset = name.indexOf(piece, ++offset)) > 0) {
int end = offset + piece.length();
if (isPatternMatch(name.substring(end), pattern)) {
return true;
}
}
} else {
// no more wildcards, need exact match to end of name
return name.endsWith(pattern);
}
}
} else {
// check for leading text before first wildcard
int split = pattern.indexOf('*');
if (split > 0) {
// match leading text to start of name
String piece = pattern.substring(0, split);
if (name.startsWith(piece)) {
return isPatternMatch(name.substring(split), pattern.substring(split));
} else {
return false;
}
} else {
// no wildcards, need exact match
return name.equals(pattern);
}
}
return false;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/LazyList.java 0000644 0001750 0001750 00000017627 11145222072 023253 0 ustar twerner twerner /*
* Copyright (c) 2006-2009, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.util;
import java.util.AbstractList;
import java.util.Iterator;
/**
* List implementation with lazy array construction and modification tracking. The lazy array construction is a minor
* optimization, to save the added overhead of a backing array for lists which are frequently empty. The modification
* tracking feature supports filtered list construction with result caching.
*
* @author Dennis M. Sosnoski
*/
public class LazyList extends AbstractList
{
/** Singleton iterator for empty collection. */
public static final Iterator EMPTY_ITERATOR = new Iterator() {
public boolean hasNext() {
return false;
}
public Object next() {
throw new IllegalStateException("Internal error - no next");
}
public void remove() {
throw new IllegalStateException("Internal error - nothing to remove");
}
};
/** Unmodifiable empty list instance. */
public static final LazyList EMPTY_LIST = new LazyList() {
public void add(int index, Object element) {
throw new UnsupportedOperationException("Internal error: Unmodifiable list");
}
public Object remove(int index) {
throw new UnsupportedOperationException("Internal error: Unmodifiable list");
}
protected void removeRange(int from, int to) {
throw new UnsupportedOperationException("Internal error: Unmodifiable list");
}
};
/** Number of items currently present in list. */
private int m_size;
/** Maximum number of items allowed before resizing. */
private int m_limit;
/** Backing array (lazy instantiation, null if not used). */
private Object[] m_array;
/**
* Make sure space is available for adding to the list. This grows the size of the backing array, if necessary.
*
* @param count
*/
private void makeSpace(int count) {
if (m_limit - m_size < count) {
Object[] copy;
if (m_array == null) {
copy = new Object[count + 4];
} else {
copy = new Object[m_size * 2 + count];
System.arraycopy(m_array, 0, copy, 0, m_size);
}
m_array = copy;
m_limit = copy.length;
}
}
/*
* (non-Javadoc)
*
* @see java.util.AbstractList#get(int)
*/
public Object get(int index) {
if (index >= 0 && index < m_size) {
return m_array[index];
} else {
throw new IndexOutOfBoundsException("Index " + index + " is out of valid range 0-" + (m_size - 1));
}
}
/*
* (non-Javadoc)
*
* @see java.util.AbstractCollection#size()
*/
public int size() {
return m_size;
}
/*
* (non-Javadoc)
*
* @see java.util.AbstractList#add(int, java.lang.Object)
*/
public void add(int index, Object element) {
if (index >= 0 && index <= m_size) {
makeSpace(1);
if (index < m_size) {
System.arraycopy(m_array, index, m_array, index + 1, m_size - index);
}
m_array[index] = element;
m_size++;
modCount++;
} else {
throw new IndexOutOfBoundsException("Index " + index + " is out of valid range 0-" + m_size);
}
}
/*
* (non-Javadoc)
*
* @see java.util.AbstractList#iterator()
*/
public Iterator iterator() {
if (m_size == 0) {
return EMPTY_ITERATOR;
} else {
return super.iterator();
}
}
/*
* (non-Javadoc)
*
* @see java.util.AbstractList#remove(int)
*/
public Object remove(int index) {
if (index >= 0 && index < m_size) {
Object item = m_array[index];
int start = index + 1;
System.arraycopy(m_array, start, m_array, index, m_size - start);
m_array[--m_size] = null;
modCount++;
return item;
} else {
throw new IndexOutOfBoundsException("Index " + index + " is out of valid range 0-" + (m_size - 1));
}
}
/*
* (non-Javadoc)
*
* @see java.util.AbstractList#set(int, java.lang.Object)
*/
public Object set(int index, Object element) {
if (index >= 0 && index < m_size) {
Object item = m_array[index];
m_array[index] = element;
return item;
} else {
throw new IndexOutOfBoundsException("Index " + index + " is out of valid range 0-" + (m_size - 1));
}
}
/*
* (non-Javadoc)
*
* @see java.util.AbstractList#removeRange(int, int)
*/
protected void removeRange(int from, int to) {
if (from >= 0 && to <= m_size) {
int length = m_size - to;
if (length > 0) {
System.arraycopy(m_array, to, m_array, from, length);
}
m_size -= to - from;
for (int i = m_size; i > to;) {
m_array[--i] = null;
}
modCount++;
} else {
throw new IndexOutOfBoundsException("Range of " + from + "-" + to + " exceeds valid range 0-" + m_size);
}
}
/**
* Get modify counter. This supports tracking changes to determine when cached filters need to be updated.
*
* @return count
*/
public int getModCount() {
return modCount;
}
/**
* Remove range of values. This is just a public version of the protected base class method
* {@link #removeRange(int, int)}
*
* @param from
* @param to
*/
public void remove(int from, int to) {
removeRange(from, to);
}
/**
* Compact the list, removing any null values.
*/
public void compact() {
int offset = 0;
while (offset < m_size) {
if (m_array[offset] == null) {
break;
} else {
offset++;
}
}
if (offset < m_size) {
int fill = offset;
while (++offset < m_size) {
if (m_array[offset] != null) {
m_array[fill++] = m_array[offset];
}
}
m_size = fill;
modCount++;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/StringSizedSet.java 0000644 0001750 0001750 00000015460 11160703042 024410 0 ustar twerner twerner /*
Copyright (c) 2009, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.util;
/**
* Fixed size hash set of String values.
*
* @author Dennis M. Sosnoski
*/
public class StringSizedSet
{
/** Default fill fraction for sizing of tables. */
public static final double DEFAULT_FILL_FRACTION = 0.4;
/** Size of array used for keys. */
protected final int m_arraySize;
/** Array of key table slots. */
protected final String[] m_keyTable;
/** Offset added (modulo table size) to slot number on collision. */
protected final int m_hitOffset;
/**
* Constructor with full specification.
*
* @param count number of values to assume in sizing of table
* @param fill fraction fill for table (maximum of 0.7, to
* prevent excessive collisions)
*/
public StringSizedSet(int count, double fill) {
// make sure the fill fraction is in a reasonable range
if (fill <= 0.0 || fill > 0.7) {
throw new IllegalArgumentException("Fill fraction of " + fill +
" is out of allowed range");
}
// compute initial table size (ensuring odd)
int size = Math.max((int) (count / fill), 11);
size += (size + 1) % 2;
m_arraySize = size;
// initialize the table information
m_keyTable = new String[size];
m_hitOffset = m_arraySize / 2;
}
/**
* Constructor with only value count specified. Uses default fill fraction
* and miss value.
*
* @param count number of values to assume in initial sizing of table
*/
public StringSizedSet(int count) {
this(count, DEFAULT_FILL_FRACTION);
}
/**
* Step the slot number for an entry. Adds the collision offset (modulo
* the table size) to the slot number.
*
* @param slot slot number to be stepped
* @return stepped slot number
*/
private final int stepSlot(int slot) {
return (slot + m_hitOffset) % m_arraySize;
}
/**
* Find free slot number for entry. Starts at the slot based directly
* on the hashed key value. If this slot is already occupied, it adds
* the collision offset (modulo the table size) to the slot number and
* checks that slot, repeating until an unused slot is found.
*
* @param slot initial slot computed from key
* @return slot at which entry was added
*/
private final int freeSlot(int slot) {
while (m_keyTable[slot] != null) {
slot = stepSlot(slot);
}
return slot;
}
/**
* Standard base slot computation for a key. This method may be used
* directly for key lookup using either the hashCode() method
* defined for the key objects or the System.identityHashCode()
* method, as selected by the hash technique constructor parameter. To
* implement a hash class based on some other methods of hashing and/or
* equality testing, define a separate method in the subclass with a
* different name and use that method instead. This avoids the overhead
* caused by overrides of a very heavily used method.
*
* @param key key value to be computed
* @return base slot for key
*/
private final int standardSlot(String key) {
return (key.hashCode() & Integer.MAX_VALUE) % m_arraySize;
}
/**
* Standard find key in table. This uses equals comparisons for
* the key values.
*
* @param key to be found in table
* @return index of matching key, or -index-1 of slot to be
* used for inserting key in table if not already present (always negative)
*/
private int standardFind(String key) {
// find the starting point for searching table
int slot = standardSlot(key);
// scan through table to find target key
while (m_keyTable[slot] != null) {
// check if we have a match on target key
if (m_keyTable[slot].equals(key)) {
return slot;
} else {
slot = stepSlot(slot);
}
}
return -slot-1;
}
/**
* Add a key to the set. If the key is already present in the set, this does
* nothing.
*
* @param key key to be added to table (non-null)
* @return true if added, false if already present
* value if key not previously present in table
*/
public boolean add(String key) {
// first validate the parameters
if (key == null) {
throw new IllegalArgumentException("null key not supported");
} else {
// check space and duplicate key
int offset = standardFind(key);
if (offset >= 0) {
return false;
} else {
// add new key to table
offset = -offset - 1;
m_keyTable[offset] = key;
return true;
}
}
}
/**
* Check if an entry is present in the table.
*
* @param key key to be found
* @return true if key found in table, false
* if not
*/
public final boolean contains(String key) {
return standardFind(key) >= 0;
}
/**
* Set the table to the empty state.
*/
public void clear() {
for (int i = 0; i < m_keyTable.length; i++) {
m_keyTable[i] = null;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/IClass.java 0000644 0001750 0001750 00000021064 11256240236 022651 0 ustar twerner twerner /*
Copyright (c) 2004-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.util;
import org.jibx.binding.classes.ClassFile;
/**
* Interface for class file information. Provides access to class field and
* method information.
*
* @author Dennis M. Sosnoski
*/
public interface IClass
{
/**
* Get class file information.
* TODO: eliminate this sucker
*
* @return class file information
*/
public ClassFile getClassFile();
/**
* Get fully qualified class name.
*
* @return fully qualified name for class
*/
public String getName();
/**
* Get signature for class as type.
*
* @return signature for class used as type
*/
public String getSignature();
/**
* Get package name.
*
* @return package name for class
*/
public String getPackage();
/**
* Get superclass.
*
* @return superclass information
*/
public IClass getSuperClass();
/**
* Get names of all interfaces implemented directly by class.
*
* @return names of all interfaces implemented directly by class
* (non-null, empty array if none)
*/
public String[] getInterfaces();
/**
* Get signatures for all types of which instances of this type are
* instances.
*
* @return all signatures supported by instances
*/
public String[] getInstanceSigs();
/**
* Check if class implements an interface.
*
* @param sig signature of interface to be checked
* @return true if interface is implemented by class,
* false if not
*/
public boolean isImplements(String sig);
/**
* Check if class is abstract.
*
* @return true if class is abstract, false if not
*/
public boolean isAbstract();
/**
* Check if class is an interface.
*
* @return true if class is an interface, false if
* not
*/
public boolean isInterface();
/**
* Check if class is modifiable.
*
* @return true if class is modifiable, false if
* not
*/
public boolean isModifiable();
/**
* Check if another class is a superclass of this one.
*
* @param name potential superclass to be checked
* @return true if named class is a superclass of this one,
* false if not
*/
public boolean isSuperclass(String name);
/**
* Get information for field. This only checks for fields that are actually
* members of the class (not superclasses).
* TODO: make this work with both static and member fields
*
* @param name field name
* @return field information, or null if field not found
*/
public IClassItem getDirectField(String name);
/**
* Get information for field. If the field is not found directly,
* superclasses are checked for inherited fields matching the supplied name.
* TODO: make this work with both static and member fields
*
* @param name field name
* @return field information, or null if field not found
*/
public IClassItem getField(String name);
/**
* Get information for best matching method. This tries to find a method
* which matches the specified name, return type, and argument types. If an
* exact match is not found it looks for a method with a return type that
* is extended or implemented by the specified type and arguments that are
* extended or implemented by the specified types. If no match is found for
* this class superclasses are checked.
* TODO: make this work with both static and member methods
*
* @param name method name
* @param type return value type name (null if indeterminant)
* @param args argument value type names (null if
* indeterminant)
* @return method information, or null if method not found
*/
public IClassItem getBestMethod(String name, String type, String[] args);
/**
* Get information for method without respect to potential trailing
* arguments or return value. If the method is not found directly,
* superclasses are checked for inherited methods matching the supplied
* name. This compares the supplied partial signature against the actual
* method signature, and considers it a match if the actual sigature starts
* with the supplied signature.
* TODO: make this work with both static and member methods
*
* @param name method name
* @param sig partial method signature to be matched
* @return method information, or null if method not found
*/
public IClassItem getMethod(String name, String sig);
/**
* Get information for method matching one of several possible signatures.
* If a match is not found directly, superclasses are checked for inherited
* methods matching the supplied name and signatures. The signature
* variations are checked in the order supplied.
* TODO: make this work with both static and member methods
*
* @param name method name
* @param sigs possible signatures for method (including return type)
* @return method information, or null if method not found
*/
public IClassItem getMethod(String name, String[] sigs);
/**
* Get information for initializer. Only the class itself is checked for an
* initializer matching the argument list signature.
*
* @param sig encoded argument list signature
* @return method information, or null if method not found
*/
public IClassItem getInitializerMethod(String sig);
/**
* Get information for static method without respect to return value. Only
* the class itself is checked for a method matching the supplied name and
* argument list signature.
*
* @param name method name
* @param sig encoded argument list signature
* @return method information, or null if method not found
*/
public IClassItem getStaticMethod(String name, String sig);
/**
* Check accessible method. Check if a field or method in another class is
* accessible from within this class.
*
* @param item field or method information
* @return true if accessible, false if not
*/
public boolean isAccessible(IClassItem item);
/**
* Check if a value of this type can be directly assigned to another type.
* This is basically the equivalent of the instanceof operator.
*
* @param other type to be assigned to
* @return true if assignable, false if not
*/
public boolean isAssignable(IClass other);
/**
* Load class in executable form.
*
* @return loaded class, or null if unable to load
*/
public Class loadClass();
/**
* Get all methods of class.
*
* @return methods
*/
public IClassItem[] getMethods();
/**
* Get all fields of class.
*
* @return fields
*/
public IClassItem[] getFields();
/**
* Get the JavaDoc comment for this class.
*
* @return comment text, or null if none or no source available
*/
public String getJavaDoc();
/**
* Get the locator which provided this class.
*
* @return locator
*/
public IClassLocator getLocator();
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/SparseArrayIterator.java 0000644 0001750 0001750 00000010412 11062041224 025423 0 ustar twerner twerner /*
* Copyright (c) 2000-2007, Dennis M. Sosnoski. 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. Neither the name of JiBX nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 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 OWNER 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.jibx.util;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* Iterator class for sparse values in an array. This type of iterator
* can be used for an object array which has references interspersed with
* nulls.
*
* @author Dennis M. Sosnoski
*/
public class SparseArrayIterator implements Iterator
{
/** Empty iterator. */
public static final SparseArrayIterator EMPTY_ITERATOR =
new SparseArrayIterator(new Object[0]);
/** Array supplying values for iteration. */
private Object[] m_array;
/** Offset of next iteration value. */
private int m_offset;
/**
* Internal constructor.
*
* @param array array containing values to be iterated
*/
private SparseArrayIterator(Object[] array) {
m_array = array;
m_offset = -1;
advance();
}
/**
* Advance to next iteration value. This advances the current position in
* the array to the next non-null value.
*
* @return true if element available, false if
* not
*/
protected boolean advance() {
while (++m_offset < m_array.length) {
if (m_array[m_offset] != null) {
return true;
}
}
return false;
}
/**
* Check for iteration element available.
*
* @return true if element available, false if
* not
*/
public boolean hasNext() {
return m_offset < m_array.length;
}
/**
* Get next iteration element.
*
* @return next iteration element
* @exception NoSuchElementException if past end of iteration
*/
public Object next() {
if (m_offset < m_array.length) {
Object result = m_array[m_offset];
advance();
return result;
} else {
throw new NoSuchElementException();
}
}
/**
* Remove element from iteration. This optional operation is not supported
* and always throws an exception.
*
* @exception UnsupportedOperationException for unsupported operation
*/
public void remove() {
throw new UnsupportedOperationException();
}
/**
* Build iterator.
*
* @param array array containing values to be iterated (may be
* null)
* @return constructed iterator
*/
public static Iterator buildIterator(Object[] array) {
if (array == null || array.length == 0) {
return EMPTY_ITERATOR;
} else {
return new SparseArrayIterator(array);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/HolderBase.java 0000644 0001750 0001750 00000015747 11326406150 023513 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.util;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
* Base class for external data used in constructing a namespaced file which may reference other files of the same type.
* This class tracks both the referenced files and the corresponding namespace references, assigning prefixes for the
* latter as appropriate. The namespace associated with this file is always given the prefix 'tns', while those used for
* other files get prefixes of the form 'ns1', 'ns2', etc.
*
* @author Dennis M. Sosnoski
*/
public abstract class HolderBase
{
private final String m_namespace;
private final Map m_nsPrefixMap;
private boolean m_finished;
private boolean m_existingFile;
private String m_fileName;
private Set m_referenceSet;
/**
* Constructor for a file being generated.
*
* @param uri (null if no-namespace binding)
*/
public HolderBase(String uri) {
m_namespace = uri;
m_nsPrefixMap = new HashMap();
if (uri != null) {
m_nsPrefixMap.put(uri, "tns");
}
}
/**
* Constructor for an existing file.
*
* @param uri (null if no-namespace binding)
* @param name file name
*/
public HolderBase(String uri, String name) {
this(uri);
m_fileName = name;
m_finished = m_existingFile = true;
}
/**
* Check if file already exists.
*
* @return true if existing file, false if not
*/
public boolean isExistingFile() {
return m_existingFile;
}
/**
* Check if file is modifiable. This will always be false for an existing file, and will be set
* false for new files when {@link #finish()} is called.
*
* @return true if file is modifiable, false if not
*/
public boolean isModifiable() {
return !m_finished;
}
/**
* Get the prefix for a namespace URI. The first time this is called for a particular namespace URI a prefix is
* assigned and returned. This assumes that the default namespace is always the no-namespace.
*
* @param uri
* @return prefix
*/
public String getPrefix(String uri) {
if (uri == null) {
return "";
} else {
String prefix = (String)m_nsPrefixMap.get(uri);
if (prefix == null) {
if (!isModifiable()) {
throw new IllegalStateException("Internal error - file is not modifiable");
}
prefix = "ns" + m_nsPrefixMap.size();
m_nsPrefixMap.put(uri, prefix);
addNamespaceDecl(prefix, uri);
}
return prefix;
}
}
/**
* Subclass hook method to handle adding a namespace declaration. The implementation of this method needs to set up
* the namespace declaration for output in the generated XML.
*
* @param prefix
* @param uri
*/
protected abstract void addNamespaceDecl(String prefix, String uri);
/**
* Get namespace URI associated with this file.
*
* @return namespace (null if no-namespace)
*/
public String getNamespace() {
return m_namespace;
}
/**
* Get the file name to be used for this file.
*
* @return name (null if not set)
*/
public String getFileName() {
return m_fileName;
}
/**
* Set the file name to be used for this file.
*
* @param name
*/
public void setFileName(String name) {
if (!isModifiable()) {
throw new IllegalStateException("Internal error - file is not modifiable");
}
m_fileName = name;
}
/**
* Record a reference from this file to another file of the same type. This adds the reference to the set of
* references. Self-references are ignored.
*
* @param ref
*/
public void addReference(HolderBase ref) {
if (ref != this && (m_referenceSet == null || !m_referenceSet.contains(ref))) {
if (!isModifiable()) {
throw new IllegalStateException("Internal error - file is not modifiable");
}
if (ref == null) {
throw new IllegalArgumentException("Reference cannot be to null");
}
if (m_referenceSet == null) {
m_referenceSet = new HashSet();
}
m_referenceSet.add(ref);
}
}
/**
* Get the set of references from this file to other files of the same type.
*
* @return references
*/
public Set getReferences() {
if (m_referenceSet == null) {
return Collections.EMPTY_SET;
} else {
return m_referenceSet;
}
}
/**
* Implementation method for subclasses to complete the construction of the file. This includes processing
* references to other files, as well as any other components of the file which need to be finalized. This method
* must be called after all references have been added, allowing the subclass to add any necessary structures to the
* file representation. Subclasses must call the base class implementation when their processing is completed.
*/
public void finish() {
m_finished = true;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/util/StringIntSizedMap.java 0000644 0001750 0001750 00000021221 11160703004 025033 0 ustar twerner twerner /*
Copyright (c) 2004-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.util;
/**
* Fixed size hash map using String values as keys mapped to
* primitive int values.
*
* @author Dennis M. Sosnoski
*/
public class StringIntSizedMap
{
/** Default fill fraction for sizing of tables. */
public static final double DEFAULT_FILL_FRACTION = 0.4;
/** Default value returned when key not found in table. */
public static final int DEFAULT_NOT_FOUND = Integer.MIN_VALUE;
/** Size of array used for keys. */
protected final int m_arraySize;
/** Array of key table slots. */
protected final String[] m_keyTable;
/** Array of value table slots. */
protected final int[] m_valueTable;
/** Value returned when key not found in table. */
protected final int m_notFoundValue;
/** Offset added (modulo table size) to slot number on collision. */
protected final int m_hitOffset;
/**
* Constructor with full specification.
*
* @param count number of values to assume in sizing of table
* @param fill fraction fill for table (maximum of 0.7, to
* prevent excessive collisions)
* @param miss value returned when key not found in table
*/
public StringIntSizedMap(int count, double fill, int miss) {
// make sure the fill fraction is in a reasonable range
if (fill <= 0.0 || fill > 0.7) {
throw new IllegalArgumentException("Fill fraction of " + fill +
" is out of allowed range");
}
// compute initial table size (ensuring odd)
int size = Math.max((int) (count / fill), 11);
size += (size + 1) % 2;
m_arraySize = size;
// initialize the table information
m_keyTable = new String[size];
m_valueTable = new int[size];
for (int i = 0; i < size; i++) {
m_valueTable[i] = -1;
}
m_hitOffset = m_arraySize / 2;
m_notFoundValue = miss;
}
/**
* Constructor with value count and miss value specified. Uses default fill
* fraction.
*
* @param count number of values to assume in initial sizing of table
* @param miss value returned when key not found in table
*/
public StringIntSizedMap(int count, int miss) {
this(count, DEFAULT_FILL_FRACTION, miss);
}
/**
* Constructor with only value count specified. Uses default fill fraction
* and miss value.
*
* @param count number of values to assume in initial sizing of table
*/
public StringIntSizedMap(int count) {
this(count, DEFAULT_FILL_FRACTION, DEFAULT_NOT_FOUND);
}
/**
* Step the slot number for an entry. Adds the collision offset (modulo
* the table size) to the slot number.
*
* @param slot slot number to be stepped
* @return stepped slot number
*/
private final int stepSlot(int slot) {
return (slot + m_hitOffset) % m_arraySize;
}
/**
* Find free slot number for entry. Starts at the slot based directly
* on the hashed key value. If this slot is already occupied, it adds
* the collision offset (modulo the table size) to the slot number and
* checks that slot, repeating until an unused slot is found.
*
* @param slot initial slot computed from key
* @return slot at which entry was added
*/
private final int freeSlot(int slot) {
while (m_keyTable[slot] != null) {
slot = stepSlot(slot);
}
return slot;
}
/**
* Standard base slot computation for a key. This method may be used
* directly for key lookup using either the hashCode() method
* defined for the key objects or the System.identityHashCode()
* method, as selected by the hash technique constructor parameter. To
* implement a hash class based on some other methods of hashing and/or
* equality testing, define a separate method in the subclass with a
* different name and use that method instead. This avoids the overhead
* caused by overrides of a very heavily used method.
*
* @param key key value to be computed
* @return base slot for key
*/
private final int standardSlot(String key) {
return (key.hashCode() & Integer.MAX_VALUE) % m_arraySize;
}
/**
* Standard find key in table. This uses equals comparisons for
* the key values.
*
* @param key to be found in table
* @return index of matching key, or -index-1 of slot to be
* used for inserting key in table if not already present (always negative)
*/
private int standardFind(String key) {
// find the starting point for searching table
int slot = standardSlot(key);
// scan through table to find target key
while (m_keyTable[slot] != null) {
// check if we have a match on target key
if (m_keyTable[slot].equals(key)) {
return slot;
} else {
slot = stepSlot(slot);
}
}
return -slot-1;
}
/**
* Add an entry to the table. If the key is already present in the table,
* this replaces the existing value associated with the key.
*
* @param key key to be added to table (non-null)
* @param value associated value for key
* @return value previously associated with key, or reserved not found
* value if key not previously present in table
*/
public int add(String key, int value) {
// first validate the parameters
if (key == null) {
throw new IllegalArgumentException("null key not supported");
} else if (value == -1) {
throw new IllegalArgumentException
("value matching not found return not supported");
} else {
// check space and duplicate key
int offset = standardFind(key);
if (offset >= 0) {
// replace existing value for key
int prior = m_valueTable[offset];
m_valueTable[offset] = value;
return prior;
} else {
// add new pair to table
offset = -offset - 1;
m_keyTable[offset] = key;
m_valueTable[offset] = value;
return m_notFoundValue;
}
}
}
/**
* Check if an entry is present in the table. This method is supplied to
* support the use of values matching the reserved not found value.
*
* @param key key for entry to be found
* @return true if key found in table, false
* if not
*/
public final boolean containsKey(String key) {
return standardFind(key) >= 0;
}
/**
* Find an entry in the table.
*
* @param key key for entry to be returned
* @return value for key, or reserved not found value if key not found
*/
public final int get(String key) {
int slot = standardFind(key);
if (slot >= 0) {
return m_valueTable[slot];
} else {
return m_notFoundValue;
}
}
/**
* Set the table to the empty state.
*/
public void clear() {
for (int i = 0; i < m_keyTable.length; i++) {
m_keyTable[i] = null;
m_valueTable[i] = m_notFoundValue;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/v2/ 0000755 0001750 0001750 00000000000 11526304016 020174 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/v2/TrackSource.java 0000644 0001750 0001750 00000004656 10752422656 023312 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.v2;
/**
* Unmarshalling source tracking interface. This interface is added to bound classes when requested by the binding
* definition. It allows the user to retrieve information about the location in the input document corresponding to an
* unmarshalled object, if the parser used for unmarshalling supports reporting this information.
*
* @author Dennis M. Sosnoski
*/
public interface TrackSource
{
/**
* Get source document name.
*
* @return name given for source document, or null if none
*/
String jibx_getDocumentName();
/**
* Get source document line number.
*
* @return line number in source document, or -1 if unknown
*/
int jibx_getLineNumber();
/**
* Get source document column number.
*
* @return column number in source document, or -1 if unknown
*/
int jibx_getColumnNumber();
} libjibx1.2-java-1.2.3/build/src/org/jibx/v2/BindingFactory.java 0000644 0001750 0001750 00000013111 10752422660 023744 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.v2;
/**
* Binding factory interface definition. This interface is implemented by the binding factory class generated by each
* binding definition. All binding factory instances are guaranteed to be threadsafe and reusable.
*
* @author Dennis M. Sosnoski
*/
public interface BindingFactory
{
/**
* Current binary version number. This is a byte-ordered value, allowing for two levels of major and two levels of
* minor version.
*/
static final int CURRENT_VERSION_NUMBER = 0x02000000;
/** Current distribution file name. This is filled in by the Ant build process to match the current distribution. */
static final String CURRENT_VERSION_NAME = "@distrib@";
/** Mask for portions of version number that effect compatibility. */
static final int COMPATIBLE_VERSION_MASK = 0xFFFF0000;
/**
* Creat instance of class for element name. This implements substitution group handling, by checking the current
* element start tag name against the expected element name, and if they're not the same finding the appropriate
* class based on the substitution group rooted on the expected element name (which must be a global element name).
*
* @param root global root element name, including namespace URI, in "lname{uri}" form
* @param rdr reader
* @param inst supplied instance of root element class or subclass (null if none)
* @return instance of appropriate class to use for unmarshalling (may be the same as the provided instance)
*/
Object createElementInstance(String root, XmlReader rdr, Object inst);
/**
* Validate instance of class for type name. This implements type substitution handling, by checking for an override
* xsi:type specification on the current element start tag, and if the type is different from the default finding
* the appropriate class and returning an instance.
*
* @param dflt global default complexType name, including namespace URI, in "lname{uri}" form
* @param rdr reader
* @param inst supplied instance of default type class or subclass (null if none)
* @return instance of appropriate class to use for unmarshalling (may be the same as the provided instance)
*/
Object createTypeInstance(String dflt, XmlReader rdr, Object inst);
/**
* Get namespaces defined in mapping. The returned array is indexed by the namespace index number used when
* marshalling.
*
* @return array of namespaces defined in binding (null if not an output binding)
*/
String[] getNamespaces();
/**
* Get initial prefixes for namespaces defined in mapping. The returned array is indexed by the namespace index
* number used when marshalling. Note that these are only the first prefixes associated with each namespace; it's
* possible to reuse the namespace in the binding with a different prefix.
*
* @return array of prefixes for namespaces defined in binding (null if not an output binding)
*/
String[] getPrefixes();
/**
* Get mapped class names (or type names, in the case of abstract mappings). Returns array of fully-qualified class
* and/or type names, ordered by index number of the class.
*
* @return array of class names
*/
String[] getMappedClasses();
/**
* Get namespaces of elements corresponding to mapped classes. The returned array uses the same ordering as the
* result of the {@link #getMappedClasses} call. Entries in the array are null if there is no element
* for a class or the element is in the default namespace.
*
* @return array of element namespaces
*/
String[] getElementNamespaces();
/**
* Get names of elements corresponding to mapped classes. The returned array uses the same ordering as the result of
* the {@link #getMappedClasses} call. Entries in the array are null if there is no element for a
* class.
*
* @return array of element names
*/
String[] getElementNames();
} libjibx1.2-java-1.2.3/build/src/org/jibx/v2/SchemaValidationContext.java 0000644 0001750 0001750 00000006741 10752422656 025642 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.v2;
import org.jibx.runtime.JiBXException;
/**
* Tracks the schema validation state. This includes order-dependent state information collected while walking the tree
* structure of a schema model. Collects all errors and warnings and maintains a summary of the severity of the problems
* found. For ease of use, this also wraps the schema name register with convenience methods for validation.
*
* @author Dennis M. Sosnoski
*/
public class SchemaValidationContext extends ValidationContext
{
private Object m_object;
public void setObject(Object obj) {
m_object = obj;
}
public void requiredPatternCheck(String name, String value, String pattern) throws JiBXException {
if (value == null) {
addError(name + " is missing (null)", m_object);
} else {
}
}
public void optionalPatternCheck(String name, String value, String pattern) throws JiBXException {
if (value == null) {
addError(name + " is missing (null)", m_object);
} else {
}
}
public void requiredLengthCheck(String name, String value, int min, int max) throws JiBXException {
if (value == null) {
addError(name + " is missing (null)", m_object);
} else {
int length = value.length();
if (length < min || length > max) {
addError(name + " must be a minimum of " + min + " and a maximum of " + max + " characters (found " +
length + " characters)", m_object);
}
}
}
public void optionalLengthCheck(String name, String value, int min, int max) throws JiBXException {
if (value != null) {
int length = value.length();
if (length < min || length > max) {
addError(name + " must be a minimum of " + min + " and a maximum of " + max + " characters (found " +
length + " characters)", m_object);
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/v2/ValidationProblem.java 0000644 0001750 0001750 00000011177 10752422656 024474 0 ustar twerner twerner /*
* Copyright (c) 2006-2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.v2;
import org.jibx.runtime.ITrackSource;
import org.jibx.runtime.ValidationException;
import org.jibx.schema.elements.SchemaBase;
/**
* Problem reported by validation. Provides the details for a specific problem item.
*
* @author Dennis M. Sosnoski
*/
public class ValidationProblem
{
// severity levels
public static final int FATAL_LEVEL = 0;
public static final int ERROR_LEVEL = 1;
public static final int WARNING_LEVEL = 2;
public static final int UNIMPLEMENTED_LEVEL = 3;
// users can add their own specific severity levels
/** Problem severity level. */
private final int m_severity;
/** Description of problem found. */
private final String m_description;
/** Component that reported problem. */
private final Object m_component;
/**
* Full constructor.
*
* @param level severity level of problem
* @param msg problem description
* @param obj source object for validation error (may be null if not specific to a particular
* component)
*/
/* package */ValidationProblem(int level, String msg, Object obj) {
m_severity = level;
if (obj == null) {
m_description = msg;
} else {
m_description = msg + " for " + componentDescription(obj);
}
m_component = obj;
}
/**
* Create description text for a component of a binding definition.
*
* @param obj binding definition component
* @return component description
*/
public static String componentDescription(Object obj) {
StringBuffer buff = new StringBuffer();
if (obj instanceof TrackSource) {
buff.append(((SchemaBase)obj).name());
buff.append(" element");
} else if (!(obj instanceof ProblemLocation)) {
String cname = obj.getClass().getName();
int split = cname.lastIndexOf('.');
if (split >= 0) {
cname = cname.substring(split + 1);
}
buff.append(cname);
}
if (obj instanceof ITrackSource) {
buff.append(" at ");
buff.append(ValidationException.describe(obj));
} else {
buff.append(" at unknown location");
}
return buff.toString();
}
/**
* Constructor using default (error) severity level.
*
* @param msg problem description
* @param obj source object for validation error
*/
/* package */ValidationProblem(String msg, Object obj) {
this(ERROR_LEVEL, msg, obj);
}
/**
* Get the main binding definition item for the problem.
*
* @return element or attribute at root of problem
*/
public Object getComponent() {
return m_component;
}
/**
* Get problem description.
*
* @return problem description
*/
public String getDescription() {
return m_description;
}
/**
* Get problem severity level.
*
* @return severity level for problem
*/
public int getSeverity() {
return m_severity;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/v2/XmlWriter.java 0000644 0001750 0001750 00000053543 10752422656 023021 0 ustar twerner twerner /*
* Copyright (c) 2004-2007, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.v2;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Date;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.MarshallingContext;
/**
* XML writer interface used for output of marshalled document. This interface allows easy substitution of different
* output formats, including parse event stream equivalents. This makes heavy use of state information, so each method
* call defined is only valid in certain states.
*
* @author Dennis M. Sosnoski
*/
public interface XmlWriter
{
/**
* Get the marshalling context associated with this writer. The marshalling context tracks higher-level information
* about the conversion of XML into a Java object structure.
*
* @return context
*/
MarshallingContext getContext();
/**
* Get the current validation context for this writer. The validation context is used both for tracking problems,
* and to determine the appropriate handling when a problem occurs.
*
* @return context
*/
ValidationContext getValidationContext();
/**
* Get the current element nesting depth. Elements are only counted in the depth returned when they're officially
* open - after the start tag has been output and before the end tag has been output.
*
* @return number of nested elements at current point in output
*/
int getNestingDepth();
/**
* Get the number of namespaces currently defined. This is equivalent to the index of the next extension namespace
* added.
*
* @return namespace count
*/
int getNamespaceCount();
/**
* Set nesting indentation. This is advisory only, and implementations of this interface are free to ignore it. The
* intent is to indicate that the generated output should use indenting to illustrate element nesting.
*
* @param count number of character to indent per level, or disable indentation if negative (zero means new line
* only)
* @param newline sequence of characters used for a line ending (null means use the single character
* '\n')
* @param indent whitespace character used for indentation
*/
void setIndent(int count, String newline, char indent);
/**
* Set attribute double-quote character usage. If this is true, the double-quote (") character is
* preferred for attribute values; if false (the default), the single-quote (') character is preferred.
* This setting is advisory only, and implementations of this interface are free to ignore it.
*
* @param prefdbl prefer double-quote flag
*/
void setAttributeDoubleQuote(boolean prefdbl);
/**
* Set boolean numeric value usage. If this is true, numeric values ('0' and '1') are preferred for
* boolean values; if false (the default), text values ('false' and 'true') are preferred. This setting
* is advisory only, and implementations of this interface are free to ignore it.
*
* @param prefnum prefer numeric boolean value flag
*/
void setBooleanNumeric(boolean prefnum);
/**
* Set the implicit namespace used for elements unless otherwise specified. The namespace must have been opened
* prior to this call.
*
* @param ns namespace URI for element (may be the empty string for the no-namespace namespace)
* @return prior implicit namespace
*/
String setImplicitNamespace(String ns);
/**
* Write the start tag for an element in the implicit namespace.
*
* @param name element name
* @throws JiBXException on unrecoverable error
*/
void startTag(String name) throws JiBXException;
/**
* Write the start tag for an element.
*
* @param ns namespace URI for element (may be the empty string for the no-namespace namespace)
* @param name unqualified element name
* @throws JiBXException on unrecoverable error
*/
void startTag(String ns, String name) throws JiBXException;
/**
* Declare a namespace, make it the implicit namespace, and write the start tag for an element in that namespace.
* This is just a shortcut for the sequence of calls {@link #openNamespace(String, String)}, {@link
* #setImplicitNamespace(String)}, {@link #startTag(String)}.
*
* @param ns namespace URI for element (may be the empty string for the no-namespace namespace)
* @param prefix prefix to be used for the namespace (use "" for default namespace declaration)
* @param name unqualified element name
* @throws JiBXException on unrecoverable error
*/
void startTagImplicit(String ns, String prefix, String name) throws JiBXException;
/**
* Add a namespace declaration to the next element start tag. If the namespace is already open this call does
* nothing.
*
* @param ns namespace URI (may be the empty string for the no-namespace namespace)
* @param prefix prefix to be used for the namespace (use "" for default namespace declaration)
* @throws JiBXException on unrecoverable error
*/
void openNamespace(String ns, String prefix) throws JiBXException;
/**
* Add no-namespace text attribute to current open start tag. This is only valid with an open start tag.
*
* @param name unqualified attribute name
* @param value text value for attribute
* @throws JiBXException on unrecoverable error
*/
void addTextAttribute(String name, String value) throws JiBXException;
/**
* Add text attribute to current open start tag. This is only valid with an open start tag.
*
* @param ns namespace URI (may be the empty string for the no-namespace namespace)
* @param name unqualified attribute name
* @param value text value for attribute
* @throws JiBXException on unrecoverable error
*/
void addTextAttribute(String ns, String name, String value) throws JiBXException;
/**
* Add optional no-namespace text attribute to current open start tag. This is only valid with an open start tag.
*
* @param name unqualified attribute name
* @param value text value for attribute (null if no value)
* @throws JiBXException on unrecoverable error
*/
void addOptionalTextAttribute(String name, String value) throws JiBXException;
/**
* Add optional text attribute to current open start tag. This is only valid with an open start tag.
*
* @param ns namespace URI (may be the empty string for the no-namespace namespace)
* @param name unqualified attribute name
* @param value text value for attribute (null if no value)
* @throws JiBXException on unrecoverable error
*/
void addOptionalTextAttribute(String ns, String name, String value) throws JiBXException;
/**
* Select text content as the destination for a conversion.
*
* @throws JiBXException on unrecoverable error
*/
void selectContent() throws JiBXException;
/**
* Select a child element in the implicit namespace as the destination for a conversion.
*
* @param name element name
* @throws JiBXException on unrecoverable error
*/
void selectContent(String name) throws JiBXException;
/**
* Select a child element as the destination for a conversion.
*
* @param ns namespace URI (may be the empty string for the no-namespace namespace)
* @param name element name
* @throws JiBXException on unrecoverable error
*/
void selectContent(String ns, String name) throws JiBXException;
/**
* Select a no-namespace attribute as the destination for a conversion. This is only valid with an open start tag.
*
* @param name unqualified attribute name
* @throws JiBXException on unrecoverable error
*/
void selectAttribute(String name) throws JiBXException;
/**
* Select an attribute as the destination for a conversion. This is only valid with an open start tag.
*
* @param ns namespace URI (may be the empty string for the no-namespace namespace)
* @param name unqualified attribute name
* @throws JiBXException on unrecoverable error
*/
void selectAttribute(String ns, String name) throws JiBXException;
/**
* Write a String value to the current text selection.
*
* @param value
* @throws JiBXException on unrecoverable error
*/
void convert(String value) throws JiBXException;
/**
* Write an int value to the current text selection.
*
* @param value
* @throws JiBXException on unrecoverable error
*/
void convert(int value) throws JiBXException;
/**
* Write a long value to the current text selection.
*
* @param value
* @throws JiBXException on unrecoverable error
*/
void convert(long value) throws JiBXException;
/**
* Write a float value to the current text selection.
*
* @param value
* @throws JiBXException on unrecoverable error
*/
void convert(float value) throws JiBXException;
/**
* Write a double value to the current text selection.
*
* @param value
* @throws JiBXException on unrecoverable error
*/
void convert(double value) throws JiBXException;
/**
* Write a boolean value to the current text selection.
*
* @param value
* @throws JiBXException on unrecoverable error
*/
void convert(boolean value) throws JiBXException;
/**
* Write a byte[] value to the current text selection using base64Binary encoding.
*
* @param value attribute value
* @throws JiBXException on unrecoverable error
*/
void convert(byte[] value) throws JiBXException;
/**
* Write a long milliseconds time value to the current text selection as an xsd:dateTime.
*
* @param value
* @throws JiBXException on unrecoverable error
*/
void convertDateTime(long value) throws JiBXException;
/**
* Write a long milliseconds time value and associated nanosecond count to the current text selection
* as an xsd:dateTime.
*
* @param value
* @param nanos
* @throws JiBXException on unrecoverable error
*/
void convertDateTime(long value, int nanos) throws JiBXException;
/**
* Write a long milliseconds time value to the current text selection as an xsd:date.
*
* @param value
* @throws JiBXException on unrecoverable error
*/
void convertDate(long value) throws JiBXException;
/**
* Write a long milliseconds time value to the current text selection as an xsd:time.
*
* @param value
* @throws JiBXException on unrecoverable error
*/
void convertTime(long value) throws JiBXException;
/**
* Write a long milliseconds time value and associated nanosecond count to the current text selection
* as an xsd:time.
*
* @param value
* @param nanos
* @throws JiBXException on unrecoverable error
*/
void convertTime(long value, int nanos) throws JiBXException;
/**
* Write a qualified name value to the current text selection. The qualified name is presented as a pair consisting
* of namespace URI and local name in order to allow flexible use.
*
* @param ns namespace URI (empty string if no-namespace namespace)
* @param name local name
* @throws JiBXException on unrecoverable error
*/
void convertQName(String ns, String name) throws JiBXException;
/**
* Write a BigDecimal value to the current text selection.
*
* @param value (non-null)
* @throws JiBXException on unrecoverable error
*/
void convert(BigDecimal value) throws JiBXException;
/**
* Write a BigInteger value to the current text selection.
*
* @param value (non-null)
* @throws JiBXException on unrecoverable error
*/
void convert(BigInteger value) throws JiBXException;
/**
* Write a text value as the content of the current element. This writes the corresponding end tag after writing the
* value.
*
* @param value content value
* @throws JiBXException on unrecoverable error
*/
void addText(String value) throws JiBXException;
/**
* Write end tag for current open element.
*
* @throws JiBXException on unrecoverable error
*/
void endTag() throws JiBXException;
/**
* Handle a missing required element value from the implicit namespace in the generated document.
*
* @param name
* @throws JiBXException on unrecoverable error
*/
void handleMissingElement(String name) throws JiBXException;
/**
* Handle a missing required element value in the generated document.
*
* @param ns
* @param name
* @throws JiBXException on unrecoverable error
*/
void handleMissingElement(String ns, String name) throws JiBXException;
/**
* Handle a missing required attribute value from the implicit namespace in the generated document.
*
* @param name
* @throws JiBXException on unrecoverable error
*/
void handleMissingAttribute(String name) throws JiBXException;
/**
* Handle a missing required attribute value in the generated document.
*
* @param ns
* @param name
* @throws JiBXException on unrecoverable error
*/
void handleMissingAttribute(String ns, String name) throws JiBXException;
/**
* Write XML declaration to document. This can only be called before any other methods in the interface are called.
*
* @param version XML version text
* @param encoding text for encoding attribute (unspecified if null)
* @param standalone text for standalone attribute (unspecified if null)
* @throws JiBXException on error writing to document
*/
void writeXMLDecl(String version, String encoding, String standalone) throws JiBXException;
/**
* Write ordinary character data text content to document.
*
* @param text content value text (must not be null)
* @throws JiBXException on error writing to document
*/
void writeTextContent(String text) throws JiBXException;
/**
* Write CDATA text to document.
*
* @param text content value text (must not be null)
* @throws JiBXException on error writing to document
*/
void writeCData(String text) throws JiBXException;
/**
* Write comment to document.
*
* @param text comment text (must not be null)
* @throws JiBXException on error writing to document
*/
void writeComment(String text) throws JiBXException;
/**
* Write entity reference to document.
*
* @param name entity name (must not be null)
* @throws JiBXException on error writing to document
*/
void writeEntityRef(String name) throws JiBXException;
/**
* Write DOCTYPE declaration to document.
*
* @param name root element name
* @param sys system ID (null if none, must be non-null for ID to be used)
* @param pub ID (null if none)
* @param subset internal subset (null if none)
* @throws JiBXException on error writing to document
*/
void writeDocType(String name, String sys, String pub, String subset) throws JiBXException;
/**
* Write processing instruction to document.
*
* @param target processing instruction target name (must not be null)
* @param data processing instruction data (must not be null)
* @throws JiBXException on error writing to document
*/
void writePI(String target, String data) throws JiBXException;
/**
* Request output indent. The writer implementation should normally indent output as appropriate. This method can be
* used to request indenting of output that might otherwise not be indented. The normal effect when used with a
* text-oriented writer should be to output the appropriate line end sequence followed by the appropriate number of
* indent characters for the current nesting level.
*
* @throws JiBXException on error writing to document
*/
void indent() throws JiBXException;
/**
* Flush document output. Writes any buffered data to the output medium. This does not flush the output
* medium itself, only any internal buffering within the writer.
*
* @throws JiBXException on error writing to document
*/
void flush() throws JiBXException;
/**
* Close document output. Completes writing of document output, including flushing and closing the output medium.
*
* @throws JiBXException on error writing to document
*/
void close() throws JiBXException;
/**
* Reset to initial state for reuse. The context is serially reusable, as long as this method is called to clear any
* retained state information between uses. It is automatically called when output is set.
*/
void reset();
/**
* Get namespace URIs for mapping. This gets the full ordered array of namespaces known in the binding used for this
* marshalling, where the index number of each namespace URI is the namespace index used to lookup the prefix when
* marshalling a name in that namespace. The returned array must not be modified.
*
* @return array of namespaces
*/
String[] getNamespaces();
/**
* Get URI for namespace.
*
* @param index namespace URI index number
* @return namespace URI text, or null if the namespace index is invalid
*/
String getNamespaceUri(int index);
/**
* Get current prefix defined for namespace.
*
* @param index namespace URI index number
* @return current prefix text, or null if the namespace is not currently mapped
*/
String getNamespacePrefix(int index);
/**
* Get index of namespace mapped to prefix. This can be an expensive operation with time proportional to the number
* of namespaces defined, so it should be used with care.
*
* @param prefix text to match (non-null, use "" for default prefix)
* @return index namespace URI index number mapped to prefix
*/
int getPrefixIndex(String prefix);
/**
* Append extension namespace URIs to those in mapping.
*
* @param uris namespace URIs to extend those in mapping
*/
void pushExtensionNamespaces(String[] uris);
/**
* Remove extension namespace URIs. This removes the last set of extension namespaces pushed using
* {@link #pushExtensionNamespaces}.
*/
void popExtensionNamespaces();
/**
* Get extension namespace URIs added to those in mapping. This gets the current set of extension definitions. The
* returned arrays must not be modified.
*
* @return array of arrays of extension namespaces (null if none)
*/
String[][] getExtensionNamespaces();
/**
* Open the specified namespaces for use. This method is normally only called internally, when namespace
* declarations are actually written to output. It is exposed as part of this interface to allow for special
* circumstances where namespaces are being written outside the usual processing. The namespaces will remain open
* for use until the current element is closed.
*
* @param nums array of namespace indexes defined by this element (must be constant, reference is kept until
* namespaces are closed)
* @param prefs array of namespace prefixes mapped by this element (no null values, use "" for
* default namespace declaration)
* @return array of indexes for namespaces not previously active (the ones actually needing to be declared, in the
* case of text output)
* @throws JiBXException on error writing to document
*/
int[] openNamespaces(int[] nums, String[] prefs) throws JiBXException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/v2/ProblemLocation.java 0000644 0001750 0001750 00000005237 10752422656 024152 0 ustar twerner twerner /*
Copyright (c) 2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.v2;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.impl.ITrackSourceImpl;
import org.jibx.runtime.impl.UnmarshallingContext;
/**
* Location of validation problem. An instance of this can be used in place of
* an unmarshalled element in cases where the validation problem prevents the
* creation of the element object.
* TODO: move this out of the schema package, generalize
*
* @author Dennis M. Sosnoski
*/
public class ProblemLocation implements ITrackSourceImpl
{
private String m_document;
private int m_line;
private int m_column;
/**
* Constructor. This initializes the location information from the context.
*
* @param ictx
*/
public ProblemLocation(IUnmarshallingContext ictx) {
((UnmarshallingContext)ictx).trackObject(this);
}
public void jibx_setSource(String name, int line, int column) {
m_document = name;
m_line = line;
m_column = column;
}
public int jibx_getColumnNumber() {
return m_column;
}
public String jibx_getDocumentName() {
return m_document;
}
public int jibx_getLineNumber() {
return m_line;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/v2/MappedType.java 0000644 0001750 0001750 00000001173 10752422660 023117 0 ustar twerner twerner package org.jibx.v2;
import org.jibx.runtime.QName;
/**
* Interface implemented by all classes corresponding to global <complexType> definitions when type substitution is
* enabled. Besides the actual interface methods, classes also define a
* public static ClassName _check_substituted(XmlReader, ClassName) method, which returns an
* unmarshalled instance of the appropriate type, after taking type substitution into account.
*/
public interface MappedType extends MappedStructure
{
/**
* Get the qualified name of this type.
*
* @return qualified name
*/
QName _get_type_qname();
} libjibx1.2-java-1.2.3/build/src/org/jibx/v2/ValidationContext.java 0000644 0001750 0001750 00000016471 11022003066 024477 0 ustar twerner twerner /*
* Copyright (c) 2006-2007, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.v2;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.ISkipElements;
import org.jibx.schema.elements.SchemaBase;
/**
* Tracks the schema validation state. This includes order-dependent state information collected while walking the tree
* structure of a schema model. Collects all errors and warnings and maintains a summary of the severity of the problems
* found. For ease of use, this also wraps the schema name register with convenience methods for validation.
*
* @author Dennis M. Sosnoski
*/
public class ValidationContext implements ISkipElements
{
/** Number of warnings reported. */
private int m_warningCount;
/** Number of errors reported. */
private int m_errorCount;
/** Number of fatals reported. */
private int m_fatalCount;
/** List of problem items reported by validation. */
private ArrayList m_problemList;
/** Set of elements to be skipped in walking tree. */
private Set m_skipSet;
/** Flag for errors to be ignored. */
private boolean m_continueOnError;
/**
* Constructor.
*/
public ValidationContext() {
m_problemList = new ArrayList();
m_skipSet = new HashSet();
}
/**
* Get number of warning problems reported.
*
* @return warning problem count
*/
public int getWarningCount() {
return m_warningCount;
}
/**
* Get number of error problems reported.
*
* @return error problem count
*/
public int getErrorCount() {
return m_errorCount;
}
/**
* Get number of fatal problems reported.
*
* @return fatal problem count
*/
public int getFatalCount() {
return m_fatalCount;
}
/**
* Add warning item. Adds a warning item to the problem list, which is a possible problem that still allows
* reasonable operation.
*
* @param msg problem description
* @param obj source object for validation error
* @throws JiBXException on unrecoverable error
*/
public void addWarning(String msg, Object obj) throws JiBXException {
addProblem(new ValidationProblem(ValidationProblem.WARNING_LEVEL, msg, obj));
}
/**
* Add error item. Adds an error item to the problem list, which is a definite problem that still allows validation
* to proceed.
*
* @param msg problem description
* @param obj source object for validation error
* @return true if to continue validation, false if not
* @throws JiBXException on unrecoverable error
*/
public boolean addError(String msg, Object obj) throws JiBXException {
addProblem(new ValidationProblem(ValidationProblem.ERROR_LEVEL, msg, obj));
return true;
}
/**
* Add fatal item. Adds a fatal item to the problem list, which is a severe problem that blocks further validation
* within the tree branch involved. The object associated with a fatal error should always be an element.
*
* @param msg problem description
* @param obj source object for validation error (should be an element)
* @throws JiBXException on unrecoverable error
*/
public void addFatal(String msg, Object obj) throws JiBXException {
addProblem(new ValidationProblem(ValidationProblem.FATAL_LEVEL, msg, obj));
}
/**
* Add problem report. The problem is added and counted as appropriate.
*
* @param problem details of problem report
* @throws JiBXException on unrecoverable error
*/
public void addProblem(ValidationProblem problem) throws JiBXException {
m_problemList.add(problem);
switch (problem.getSeverity())
{
case ValidationProblem.ERROR_LEVEL:
m_errorCount++;
break;
case ValidationProblem.FATAL_LEVEL:
m_fatalCount++;
addSkip(problem.getComponent());
throw new JiBXException("Unrecoverable error " + problem.getDescription());
case ValidationProblem.WARNING_LEVEL:
m_warningCount++;
break;
}
}
/**
* Get list of problems.
*
* @return problem list
*/
public ArrayList getProblems() {
return m_problemList;
}
/**
* Add element to set to be skipped.
*
* @param skip
*/
protected void addSkip(Object skip) {
if (skip instanceof SchemaBase) {
m_skipSet.add(skip);
}
}
//
// ISkipElements implementation
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ISkipElements#isSkipped(java.lang.Object)
*/
public boolean isSkipped(Object obj) {
return m_skipSet.contains(obj);
}
// so what kinds of errors need to be handled? there's the obvious, like missing element when unmarshalling, data
// conversion error, etc. - but how specific do I want to make the handling? can I come up with a small number of
// specific errors that I can add directly to the context? missing element, for instance, should give the actual
// element name. do I want to build in XPath-like navigation, too? could kind of do this when marshalling or
// unmarshalling, since I have the path information, but that leaves the issue of position in a collection. should
// I optionally implement a generic collection approach for the generated classes? to support full XPath I'd need
// to create methods to handle attribute and child element lookup by name, which might be not too difficult.
public void handleMissingElement() throws JiBXException {
if (m_continueOnError) {
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/v2/XmlReader.java 0000644 0001750 0001750 00000057545 11345522102 022737 0 ustar twerner twerner /*
* Copyright (c) 2005-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.v2;
import java.io.InputStream;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Date;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.UnmarshallingContext;
/**
* XML reader interface used for input to the unmarshalling code. This interface allows easy substitution of different
* parsers or other input sources.
*
* @author Dennis M. Sosnoski
*/
public interface XmlReader
{
//
// Event types reported by nextEvent() method
static final int START_DOCUMENT = 0;
static final int END_DOCUMENT = 1;
static final int START_TAG = 2;
static final int END_TAG = 3;
static final int TEXT = 4;
static final int CDSECT = 5;
static final int ENTITY_REF = 6;
static final int IGNORABLE_WHITESPACE = 7;
static final int PROCESSING_INSTRUCTION = 8;
static final int COMMENT = 9;
static final int DOCDECL = 10;
/**
* Get the current validation context for this reader. The validation context is used both for tracking problems,
* and to determine the appropriate handling when a problem occurs.
*
* @return context
*/
ValidationContext getValidationContext();
/**
* Push a validation context on this reader. The supplied validation context is popped after processing the end tag
* for the current element.
*
* @param vctx context
*/
void pushValidationContext(ValidationContext vctx);
/**
* Get the unmarshalling context associated with this reader. The unmarshalling context tracks higher-level
* information about the conversion of XML into a Java object structure.
*
* @return context
*/
UnmarshallingContext getBindingContext();
/**
* Build current parse input position description.
*
* @return text description of current parse position
*/
String buildPositionString();
/**
* Advance to next parse event of input document.
*
* @return parse event type code
* @throws JiBXException if error reading or parsing document
*/
int nextToken() throws JiBXException;
/**
* Advance to next binding component of input document. This is a higher-level operation than {@link #nextToken()},
* which consolidates text content and ignores parse events for components such as comments and PIs.
*
* @return parse event type code
* @throws JiBXException if error reading or parsing document
*/
int next() throws JiBXException;
/**
* Gets the current parse event type, without changing the current parse state.
*
* @return parse event type code
* @throws JiBXException if error parsing document
*/
int getEventType() throws JiBXException;
/**
* Get element name from the current start or end tag.
*
* @return local name if namespace handling enabled, full name if namespace handling disabled
* @throws IllegalStateException if not at a start or end tag (optional)
*/
String getName();
/**
* Get element namespace from the current start or end tag.
*
* @return namespace URI if namespace handling enabled and element is in a namespace, empty string otherwise
* @throws IllegalStateException if not at a start or end tag (optional)
*/
String getNamespace();
/**
* Get element prefix from the current start or end tag.
*
* @return prefix text (null if no prefix)
* @throws IllegalStateException if not at a start or end tag
*/
String getPrefix();
/**
* Set the implicit namespace used for elements unless otherwise specified.
*
* @param ns namespace URI for element (may be the empty string for the no-namespace namespace)
* @return prior implicit namespace
*/
String setImplicitNamespace(String ns);
/**
* Advance to a start or end tag, and verify it is the named start tag in the implicit namespace.
*
* @param name element name
* @return true if tag found, false if not (recoverable error case)
* @throws JiBXException on unrecoverable error
*/
boolean requireStartTag(String name) throws JiBXException;
/**
* Advance to a start or end tag, and verify it is the named start tag.
*
* @param ns namespace URI for element (may be the empty string for the no-namespace namespace)
* @param name element name
* @return true if tag found, false if not (exception not thrown)
* @throws JiBXException on unrecoverable error
*/
boolean requireStartTag(String ns, String name) throws JiBXException;
/**
* Advance to a start or end tag, and check if it is the named start tag in the implicit namespace.
*
* @param name element name
* @return true if match, false if not
* @throws JiBXException on unrecoverable error
*/
boolean checkStartTag(String name) throws JiBXException;
/**
* Advance to a start or end tag, and verify it is the named start tag.
*
* @param ns namespace URI for element (may be the empty string for the no-namespace namespace)
* @param name element name
* @return true if match, false if not
* @throws JiBXException on unrecoverable error
*/
boolean checkStartTag(String ns, String name) throws JiBXException;
/**
* Advance to the next start or end tag, and verify it is the close tag for the current open element.
*
* @throws JiBXException on unrecoverable error
*/
void requireEndTag() throws JiBXException;
/**
* Get current element text. This is only valid with an open start tag, and reads past the text content of the
* element, leaving the reader positioned on the next element start or end tag following the text.
*
* @return text for current element (may be null, in the case of a recoverable error)
* @throws IllegalStateException if not at a start tag
* @throws JiBXException on unrecoverable error
*/
String getElementText() throws JiBXException;
/**
* Get current text. When positioned on a TEXT event this returns the actual text; for CDSECT it returns the text
* inside the CDATA section; for COMMENT, DOCDECL, or PROCESSING_INSTRUCTION it returns the text inside the
* structure.
*
* @return text for current event (may be null, in the case of a recoverable error)
* @throws JiBXException on unrecoverable error
*/
CharSequence getText() throws JiBXException;
/**
* Get the number of attributes of the current start tag.
*
* @return number of attributes
* @throws IllegalStateException if not at a start tag (optional)
*/
int getAttributeCount();
/**
* Get an attribute name from the current start tag.
*
* @param index attribute index
* @return local name if namespace handling enabled, full name if namespace handling disabled
* @throws IllegalStateException if not at a start tag or invalid index
*/
String getAttributeName(int index);
/**
* Get an attribute namespace from the current start tag.
*
* @param index attribute index
* @return namespace URI if namespace handling enabled and attribute is in a namespace, empty string otherwise
* @throws IllegalStateException if not at a start tag or invalid index
*/
String getAttributeNamespace(int index);
/**
* Get an attribute prefix from the current start tag.
*
* @param index attribute index
* @return prefix for attribute (null if no prefix present)
* @throws IllegalStateException if not at a start tag or invalid index
*/
String getAttributePrefix(int index);
/**
* Get the index of a no-namespace attribute from the current start tag.
*
* @param name attribute name
* @return attribute index (-1 if not found)
* @throws IllegalStateException if not at a start tag
*/
int getAttributeIndex(String name);
/**
* Get the index of an attribute from the current start tag.
*
* @param ns namespace URI for attribute (may be the empty string for the no-namespace namespace)
* @param name attribute name
* @return attribute index (-1 if not found)
* @throws IllegalStateException if not at a start tag
*/
int getAttributeIndex(String ns, String name);
/**
* Get a required text attribute value from the current start tag.
*
* @param index attribute index (error if negative)
* @return value text (may be null, in the case of a recoverable error)
* @throws IllegalStateException if not at a start tag or invalid index
* @throws JiBXException on unrecoverable error
*/
String getAttributeText(int index) throws JiBXException;
/**
* Read a required text attribute value from the current start tag with whitespace collapsed.
*
* @param index attribute index (error if negative)
* @return value text (may be null, in the case of a recoverable error)
* @throws IllegalStateException if not at a start tag or invalid index
* @throws JiBXException on unrecoverable error
*/
String getAttributeCollapsed(int index) throws JiBXException;
/**
* Read an optional text attribute value from the current start tag.
*
* @param name attribute name
* @return value text, null if attribute not present
* @throws IllegalStateException if not at a start tag or invalid index
*/
String getOptionalAttributeText(String name);
/**
* Read an optional text attribute value from the current start tag.
*
* @param ns namespace URI for attribute (may be the empty string for the no-namespace namespace)
* @param name attribute name
* @return value text, null if attribute not present
* @throws IllegalStateException if not at a start tag or invalid index
*/
String getOptionalAttributeText(String ns, String name);
/**
* Read a required text attribute value from the current start tag.
*
* @param name attribute name
* @return value text, null if attribute not present and recoverable error
* @throws JiBXException if attribute not present and unrecoverable error
* @throws IllegalStateException if not at a start tag or invalid index
*/
String getRequiredAttributeText(String name) throws JiBXException;
/**
* Read a required text attribute value from the current start tag.
*
* @param ns namespace URI for attribute (may be the empty string for the no-namespace namespace)
* @param name attribute name
* @return value text, null if attribute not present and recoverable error
* @throws JiBXException if attribute not present and unrecoverable error
* @throws IllegalStateException if not at a start tag or invalid index
*/
String getRequiredAttributeText(String ns, String name) throws JiBXException;
/**
* Select the current text content for conversion.
*
* @throws JiBXException on unrecoverable error
*/
void selectText() throws JiBXException;
/**
* Select an attribute value from the current start tag as text for conversion.
*
* @param index attribute index (error if negative)
* @throws IllegalStateException if not at a start tag or invalid index
* @throws JiBXException on unrecoverable error
*/
void selectAttribute(int index) throws JiBXException;
/**
* Select an optional no-namespace attribute value from the current start tag as text for conversion.
*
* @param name attribute name
* @return true if attribute present, false if not
* @throws IllegalStateException if not at a start tag
*/
boolean selectOptionalAttribute(String name);
/**
* Select a required no-namespace attribute value from the current start tag as text for conversion.
*
* @param name attribute name
* @throws IllegalStateException if not at a start tag
* @throws JiBXException on unrecoverable error
*/
void selectRequiredAttribute(String name) throws JiBXException;
/**
* Select an optional attribute value from the current start tag as text for conversion.
*
* @param ns namespace URI for attribute (may be the empty string for the no-namespace namespace)
* @param name attribute name
* @return true if attribute present, false if not
* @throws IllegalStateException if not at a start tag
*/
boolean selectOptionalAttribute(String ns, String name);
/**
* Select a required attribute value from the current start tag as text for conversion.
*
* @param ns namespace URI for attribute (may be the empty string for the no-namespace namespace)
* @param name attribute name
* @throws IllegalStateException if not at a start tag
* @throws JiBXException on unrecoverable error
*/
void selectRequiredAttribute(String ns, String name) throws JiBXException;
/**
* Convert a String value from the current source selection. This is an empty conversion, which always
* just returns the text.
*
* @return text (null if selection missing)
* @throws JiBXException if unrecoverable conversion error
*/
String convertString() throws JiBXException;
/**
* Convert an int value from the current source selection. This always uses whitespace collapsed
* processing.
*
* @return converted value (0 if selection missing or in error)
* @throws JiBXException if unrecoverable conversion error
*/
int convertIntPrimitive() throws JiBXException;
/**
* Convert an Integer value from the current source selection. This always uses whitespace collapsed
* processing.
*
* @return converted value (null if selection missing or in error)
* @throws JiBXException if unrecoverable conversion error
*/
Integer convertInteger() throws JiBXException;
/**
* Convert a long value from the current source selection. This always uses whitespace collapsed
* processing.
*
* @return converted value (0 if selection missing or in error)
* @throws JiBXException if unrecoverable conversion error
*/
long convertLongPrimitive() throws JiBXException;
/**
* Convert a Long value from the current source selection. This always uses whitespace collapsed
* processing.
*
* @return converted value (null if selection missing or in error)
* @throws JiBXException if unrecoverable conversion error
*/
Long convertLong() throws JiBXException;
/**
* Convert a float value from the current source selection. This always uses whitespace collapsed
* processing.
*
* @return converted value (0 if selection missing or in error)
* @throws JiBXException if unrecoverable conversion error
*/
long convertFloatPrimitive() throws JiBXException;
/**
* Convert a Float value from the current source selection. This always uses whitespace collapsed
* processing.
*
* @return converted value (null if selection missing or in error)
* @throws JiBXException if unrecoverable conversion error
*/
Long convertFloat() throws JiBXException;
/**
* Convert a boolean value from the current source selection. This always uses whitespace collapsed
* processing.
*
* @return converted value (false if selection missing or in error)
* @throws JiBXException if unrecoverable conversion error
*/
long convertBooleanPrimitive() throws JiBXException;
/**
* Convert a Boolean value from the current source selection. This always uses whitespace collapsed
* processing.
*
* @return converted value (null if selection missing or in error)
* @throws JiBXException if unrecoverable conversion error
*/
Long convertBoolean() throws JiBXException;
/**
* Convert a byte[] value from the current source selection using base64Binary encoding. This always
* uses whitespace collapsed processing.
*
* @return converted value (null if selection missing or in error)
* @throws JiBXException if unrecoverable conversion error
*/
byte[] convertBase64() throws JiBXException;
/**
* Convert an InputStream value from the current source selection using base64Binary encoding. This
* always uses whitespace collapsed processing. For transports supporting attachments, the data for the stream may
* come from an attachment.
*
* @return converted value (null if selection missing or in error)
* @throws JiBXException if unrecoverable conversion error
*/
InputStream convertBase64Stream() throws JiBXException;
/**
* Convert a Date value from the current source selection. This always uses whitespace collapsed
* processing.
*
* @return converted value (null if selection missing or in error)
* @throws JiBXException if unrecoverable conversion error
*/
Date convertDateTime() throws JiBXException;
/**
* Convert a BigDecimal value from the current source selection. This always uses whitespace
* collapsed processing.
*
* @return converted value (null if selection missing or in error)
* @throws JiBXException if unrecoverable conversion error
*/
BigDecimal convertBigDecimal() throws JiBXException;
/**
* Convert a BigInteger value from the current source selection. This always uses whitespace
* collapsed processing.
*
* @return converted value (null if selection missing or in error)
* @throws JiBXException if unrecoverable conversion error
*/
BigInteger convertBigInteger() throws JiBXException;
/**
* Read current element text. This is only valid with an open start tag, and reads past the corresponding end tag
* after reading the value.
*
* @return text for current event
* @throws IllegalStateException if not at a start tag or invalid index
*/
String readText();
/**
* Creat instance of class for element name. This implements substitution group handling, by checking the current
* element start tag name against the expected element name, and if they're not the same finding the appropriate
* class based on the substitution group rooted on the expected element name (which must be a global element name).
*
* @param root global root element name, including namespace URI, in "lname{uri}" form
* @param rdr reader
* @param inst supplied instance of root element class or subclass (null if none)
* @return instance of appropriate class to use for unmarshalling (may be the same as the provided instance)
*/
Object createElementInstance(String root, XmlReader rdr, Object inst);
/**
* Validate instance of class for type name. This implements type substitution handling, by checking for an override
* xsi:type specification on the current element start tag, and if the type is different from the default finding
* the appropriate class.
*
* @param dflt global default complexType name, including namespace URI, in "lname{uri}" form
* @param rdr reader
* @param inst supplied instance of default type class or subclass (null if none)
* @return instance of appropriate class to use for unmarshalling (may be the same as the provided instance)
*/
Object createTypeInstance(String dflt, XmlReader rdr, Object inst);
/**
* Get current element nesting depth. The returned depth always includes the current start or end tag (if positioned
* on a start or end tag).
*
* @return element nesting depth
*/
int getNestingDepth();
/**
* Get number of namespace declarations active at depth.
*
* @param depth element nesting depth
* @return number of namespaces active at depth
* @throws IllegalArgumentException if invalid depth
*/
int getNamespaceCount(int depth);
/**
* Get namespace URI.
*
* @param index declaration index
* @return namespace URI
* @throws IllegalArgumentException if invalid index
*/
String getNamespaceUri(int index);
/**
* Get namespace prefix.
*
* @param index declaration index
* @return namespace prefix, null if a default namespace
* @throws IllegalArgumentException if invalid index
*/
String getNamespacePrefix(int index);
/**
* Get document name.
*
* @return document name, null if not known
*/
String getDocumentName();
/**
* Get current source line number.
*
* @return line number from source document, -1 if line number information not available
*/
int getLineNumber();
/**
* Get current source column number.
*
* @return column number from source document, -1 if column number information not available
*/
int getColumnNumber();
/**
* Get namespace URI associated with prefix.
*
* @param prefix to be found
* @return associated URI (null if prefix not defined)
*/
String getNamespace(String prefix);
/**
* Return the input encoding, if known. This is only valid after parsing of a document has been started.
*
* @return input encoding (null if unknown)
*/
String getInputEncoding();
/**
* Return namespace processing flag.
*
* @return namespace processing flag (true if namespaces are processed by reader, false
* if not)
*/
boolean isNamespaceAware();
} libjibx1.2-java-1.2.3/build/src/org/jibx/v2/MappedStructure.java 0000644 0001750 0001750 00000003362 10752422660 024200 0 ustar twerner twerner package org.jibx.v2;
import org.jibx.runtime.JiBXException;
/**
* Interface implemented by all classes corresponding to global schema definitions and <complexType> definitions
* (global or nested). This includes <attributeGroup> and <group> definitions, as well as global <attribute>
* and <element> definitions. Besides the actual interface methods, classes which correspond to a complexType must
* define an unmarshalling method public static ClassName _check_substituted(XmlReader, ClassName) to check
* for type substitution, those which correspond to an element or group must define a method public static boolean
* _is_present() to check if an optional instance of the element or group is present, and classes which
* correspond to anything other than a complexType must define a public static ClassName
* _check_instance(ClassName) method to return an instance of the class (where the supplied instance may be
* null, or an instance of a subclass).
*/
public interface MappedStructure
{
/**
* Marshal the structure representation. In the case of an <attribute>, <attributeGroup>, or <complexType>
* structure the writer must be positioned on the element start tag at the time of this call.
*
* @param wrtr
* @throws JiBXException
*/
void _marshal(XmlWriter wrtr) throws JiBXException;
/**
* Unmarshal the structure representation. In the case of an <attribute>, <attributeGroup>, or
* <complexType> structure the reader must be positioned on the element start tag at the time of this call.
*
* @param rdr
* @throws JiBXException
*/
void _unmarshal(XmlReader rdr) throws JiBXException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/v2/MappedElement.java 0000644 0001750 0001750 00000000563 10752422660 023571 0 ustar twerner twerner package org.jibx.v2;
import org.jibx.runtime.QName;
/**
* Interface implemented by all classes corresponding to schema global <element> definitions.
*/
public interface MappedElement extends MappedStructure
{
/**
* Get the qualified name of the element used for this instance.
*
* @return qualified name
*/
QName _get_element_qname();
} libjibx1.2-java-1.2.3/build/src/org/jibx/custom/ 0000755 0001750 0001750 00000000000 11526304016 021157 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/custom/CustomUtils.java 0000644 0001750 0001750 00000010113 10752422242 024313 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom;
import java.io.File;
import java.util.HashSet;
import java.util.Set;
/**
* Support methods used by customization code.
*
* @author Dennis M. Sosnoski
*/
public class CustomUtils
{
/**
* Utility method to add an array of names to a set, ignoring case. All the supplied names are converted to lower
* case before they are added to the set.
*
* @param names (null if none)
* @param set base set of names (null if none)
* @return name set (null if none)
*/
public static Set addNoCaseSet(String[] names, Set set) {
if (names == null) {
return set;
} else {
if (set == null) {
set = new HashSet();
}
for (int i = 0; i < names.length; i++) {
set.add(names[i].toLowerCase());
}
return set;
}
}
/**
* Utility method to build a set from an array of names, ignoring case. All the supplied names are converted to
* lower case before they are added to the set.
*
* @param names (null if none)
* @return name set (null if name array also null, otherwise non-null)
*/
public static Set noCaseNameSet(String[] names) {
if (names == null) {
return null;
} else {
HashSet set = new HashSet();
for (int i = 0; i < names.length; i++) {
set.add(names[i].toLowerCase());
}
return set;
}
}
/**
* Utility method to build a set from an array of names.
*
* @param names (null if none)
* @return name set (null if name array also null, otherwise non-null)
*/
public static Set nameSet(String[] names) {
if (names == null) {
return null;
} else {
HashSet set = new HashSet();
for (int i = 0; i < names.length; i++) {
set.add(names[i]);
}
return set;
}
}
/**
* Clean directory by recursively deleting children.
*
* @param dir directory to be cleaned
*/
public static void clean(File dir) {
if (dir.isDirectory()) {
File[] files = dir.listFiles();
for (int i = 0; i < files.length; i++) {
File file = files[i];
if (file.isDirectory()) {
clean(file);
}
file.delete();
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/custom/CustomizationCommandLineBase.java 0000644 0001750 0001750 00000034124 11320226166 027601 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
/**
* Command line processor for all types of customizable tools. This just provides the basic handling of a customizations
* file, target directory, and overrides of values in the customizations root object.
* TODO: should extend SchemaCommandLinebase
*
* @author Dennis M. Sosnoski
*/
public abstract class CustomizationCommandLineBase
{
/** Array of method parameter classes for single String parameter. */
public static final Class[] STRING_PARAMETER_ARRAY = new Class[] { String.class };
/** Array of classes for String and unmarshaller parameters. */
public static final Class[] STRING_UNMARSHALLER_PARAMETER_ARRAY =
new Class[] { String.class, IUnmarshallingContext.class };
/** Number of leading characters in usage lines checked for uniqueness. */
private static final int USAGE_UNIQUE_CHARS = 4;
/** Ordered array of usage lines for parameters at this level. */
private static final String[] COMMON_USAGE_LINES =
new String[] {
" -c path input customizations file",
" -t path target directory for generated output (default is current directory)",
" -w wipe all existing files from generation directory (ignored if current\n" +
" directory)",
" -v verbose output flag" };
/** Complete array of usage lines. */
private final String[] m_usageLines;
/** List of specified classes or files. */
private List m_extraArgs;
/** Target directory for output. */
private File m_generateDirectory;
/** Verbose output flag. */
private boolean m_verbose;
/**
* Constructor. This just merges the usage line defined by subclasses with those at this level, and checks for any
* duplication (by comparing the first n characters of the lines).
*
* @param lines
*/
protected CustomizationCommandLineBase(String[] lines) {
m_usageLines = mergeUsageLines(lines, COMMON_USAGE_LINES);
for (int i = 1; i < m_usageLines.length; i++) {
String line = m_usageLines[i];
if (m_usageLines[i-1].startsWith(line.substring(0, USAGE_UNIQUE_CHARS))) {
throw new IllegalArgumentException("Internal error - duplicate parameter flags");
}
}
}
/**
* Process command line arguments array.
*
* @param args
* @return true if valid, false if not
* @throws JiBXException
* @throws IOException
*/
public boolean processArgs(String[] args) throws JiBXException, IOException {
boolean wipe = false;
String custom = null;
String genpath = null;
Map overrides = new HashMap();
ArgList alist = new ArgList(args);
m_extraArgs = new ArrayList();
while (alist.hasNext()) {
String arg = alist.next();
if ("-c".equalsIgnoreCase(arg)) {
custom = alist.next();
} else if ("-t".equalsIgnoreCase(arg)) {
genpath = alist.next();
} else if ("-v".equalsIgnoreCase(arg)) {
m_verbose = true;
} else if ("-w".equalsIgnoreCase(arg)) {
wipe = true;
} else if (arg.startsWith("--") && arg.length() > 2 && Character.isLetter(arg.charAt(2))) {
if (!putKeyValue(arg.substring(2), overrides)) {
alist.setValid(false);
}
} else if (!checkParameter(alist)) {
if (arg.startsWith("-")) {
System.err.println("Unknown option flag '" + arg + '\'');
alist.setValid(false);
} else {
m_extraArgs.add(alist.current());
break;
}
}
}
// collect the extra arguments at end
while (alist.hasNext()) {
String arg = alist.next();
if (arg.startsWith("-")) {
System.err.println("Command line options must precede all other arguments: error on '" + arg + '\'');
alist.setValid(false);
break;
} else {
m_extraArgs.add(arg);
}
}
// check for valid command line arguments
if (alist.isValid()) {
// set output directory
if (genpath == null) {
m_generateDirectory = new File(".");
wipe = false;
} else {
m_generateDirectory = new File(genpath);
}
if (m_generateDirectory.exists()) {
if (!m_generateDirectory.isDirectory()) {
System.out.println("Target path '" + genpath + "' must be a directory");
alist.setValid(false);
}
} else {
m_generateDirectory.mkdirs();
wipe = false;
}
if (!m_generateDirectory.canWrite()) {
System.err.println("Target directory " + m_generateDirectory.getPath() + " is not writable");
alist.setValid(false);
} else {
// finish the command line processing
finishParameters(alist);
// report on the configuration
if (m_verbose) {
verboseDetails();
System.out.println("Output to directory " + m_generateDirectory);
}
// clean generate directory if requested
if (wipe) {
CustomUtils.clean(m_generateDirectory);
}
// load customizations and check for errors
if (!loadCustomizations(custom)) {
alist.setValid(false);
} else {
// apply command line overrides to customizations
Map unknowns = applyOverrides(overrides);
if (!unknowns.isEmpty()) {
for (Iterator iter = unknowns.keySet().iterator(); iter.hasNext();) {
String key = (String)iter.next();
System.err.println("Unknown override key '" + key + '\'');
}
alist.setValid(false);
}
}
}
} else {
printUsage();
}
return alist.isValid();
}
/**
* Get generate directory.
*
* @return directory
*/
public File getGeneratePath() {
return m_generateDirectory;
}
/**
* Get extra arguments from command line. These extra arguments must follow all parameter flags.
*
* @return args
*/
public List getExtraArgs() {
return m_extraArgs;
}
/**
* Check if verbose output requested.
*
* @return verbose
*/
public boolean isVerbose() {
return m_verbose;
}
/**
* Set a key=value definition in a map. This is a command line processing assist method that prints an error message
* directly if the expected format is not found.
*
* @param def
* @param map
* @return true if successful, false if error
*/
public static boolean putKeyValue(String def, Map map) {
int split = def.indexOf('=');
if (split >= 0) {
String key = def.substring(0, split);
if (map.containsKey(key)) {
System.err.println("Repeated key item: '" + def + '\'');
return false;
} else {
map.put(key, def.substring(split + 1));
return true;
}
} else {
System.err.println("Missing '=' in expected key=value item: '" + def + '\'');
return false;
}
}
/**
* Get the usage lines describing command line parameters.
*
* @return lines
*/
protected String[] getUsageLines() {
return m_usageLines;
}
/**
* Merge two arrays of strings, returning an ordered array containing all the strings from both provided arrays.
*
* @param base
* @param adds
* @return ordered merged
*/
protected static String[] mergeUsageLines(String[] base, String[] adds) {
if (adds.length == 0) {
return base;
} else {
String fulls[] = new String[base.length + adds.length];
System.arraycopy(base, 0, fulls, 0, base.length);
System.arraycopy(adds, 0, fulls, base.length, adds.length);
Arrays.sort(fulls);
return fulls;
}
}
/**
* Check extension parameter. This method may be overridden by subclasses to process parameters beyond those known
* to this base class.
*
* @param alist argument list
* @return true if parameter processed, false if unknown
*/
protected boolean checkParameter(ArgList alist) {
return false;
}
/**
* Finish processing of command line parameters. This method may be overridden by subclasses to implement any added
* processing after all the command line parameters have been handled.
*
* @param alist
*/
protected void finishParameters(ArgList alist) {}
/**
* Print any extension details. This method may be overridden by subclasses to print extension parameter values for
* verbose output.
*/
protected void verboseDetails() {}
/**
* Load the customizations file. This method must load the specified customizations file, or create a default
* customizations instance, of the appropriate type.
*
* @param path customization file path, null if none
* @return true if successful, false if an error
* @throws JiBXException
* @throws IOException
*/
protected abstract boolean loadCustomizations(String path) throws JiBXException, IOException;
/**
* Apply map of override values to customizations read from file or created as default.
*
* @param overmap override key-value map
* @return map for key/values not recognized
*/
protected abstract Map applyOverrides(Map overmap);
/**
* Print usage information.
*/
public abstract void printUsage();
/**
* Wrapper class for command line argument list.
*/
protected static class ArgList
{
private int m_offset;
private final String[] m_args;
private boolean m_valid;
/**
* Constructor.
*
* @param args
*/
protected ArgList(String[] args) {
m_offset = -1;
m_args = args;
m_valid = true;
}
/**
* Check if another argument value is present.
*
* @return true if argument present, false if all processed
*/
public boolean hasNext() {
return m_args.length - m_offset > 1;
}
/**
* Get current argument value.
*
* @return argument, or null if none
*/
public String current() {
return (m_offset >= 0 && m_offset < m_args.length) ? m_args[m_offset] : null;
}
/**
* Get next argument value. If this is called with no argument value available it sets the argument list
* invalid.
*
* @return argument, or null if none
*/
public String next() {
if (++m_offset < m_args.length) {
return m_args[m_offset];
} else {
m_valid = false;
return null;
}
}
/**
* Set valid state.
*
* @param valid
*/
public void setValid(boolean valid) {
m_valid = valid;
}
/**
* Check if argument list valid.
*
* @return true if valid, false if not
*/
public boolean isValid() {
return m_valid;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/ 0000755 0001750 0001750 00000000000 11526304016 022614 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/IApply.java 0000644 0001750 0001750 00000004117 11062041246 024656 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom.classes;
import org.jibx.util.IClassLocator;
/**
* Apply customizations interface. This is used by the {@link GlobalCustom} class to fill out the customization details
* for all unmarshalled components, including extension components from other packages.
*
* @author Dennis M. Sosnoski
*/
public interface IApply
{
/**
* Apply customizations to default values. This is called to fill in the details for this customization (and all
* child customization components).
*
* @param loc class locator
*/
public void apply(IClassLocator loc);
}
libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/SharedNestingBase.java 0000644 0001750 0001750 00000022774 11261753152 027031 0 ustar twerner twerner /*
* Copyright (c) 2007-2009 Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom.classes;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.util.StringArray;
/**
* Base class for all binding customizations that can contain other customizations. This includes inherited values
* shared with customization extensions (in particular, the WSDL extensions).
*
* @author Dennis M. Sosnoski
*/
public abstract class SharedNestingBase extends CustomBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "javadoc-formatter", "name-style", "namespace", "namespace-style", "require",
"use-javadocs" });
// values inherited through nesting
private String m_javadocFormatter;
private String m_namespace;
private Integer m_namespaceStyle;
private Integer m_nameStyle;
private Integer m_require;
private Boolean m_useJavaDocs;
// value set by subclasses
private String m_actualNamespace;
/**
* Constructor.
*
* @param parent
*/
public SharedNestingBase(SharedNestingBase parent) {
super(parent);
}
//
// Access methods for values inherited through nesting
/**
* Get JavaDoc formatter class name.
*
* @return namespace style
*/
public String getFormatterClass() {
if (m_javadocFormatter == null) {
if (getParent() == null) {
return IDocumentFormatter.DEFAULT_IMPLEMENTATION;
} else {
return getParent().getFormatterClass();
}
} else {
return m_javadocFormatter;
}
}
/**
* Get namespace specified on this element. This method is only intended for use by subclasses - otherwise the
* {@link #getNamespace()} method should instead be used.
*
* @return namespace (null if none)
*/
protected String getSpecifiedNamespace() {
return m_namespace;
}
/**
* Get namespace derivation style.
*
* @return namespace style
*/
public int getNamespaceStyle() {
if (m_namespaceStyle == null) {
if (getParent() == null) {
return DERIVE_BY_PACKAGE;
} else {
return getParent().getNamespaceStyle();
}
} else {
return m_namespaceStyle.intValue();
}
}
/**
* Set namespace derivation style.
*
* @param style (null if none at this level)
*/
public void setNamespaceStyle(Integer style) {
m_namespaceStyle = style;
}
/**
* Get name style.
*
* @return name style
*/
public int getNameStyle() {
if (m_nameStyle == null) {
if (getParent() == null) {
return CAMEL_CASE_NAMES;
} else {
return getParent().getNameStyle();
}
} else {
return m_nameStyle.intValue();
}
}
/**
* Set name style.
*
* @param style (null if none at this level)
*/
public void setNameStyle(Integer style) {
m_nameStyle = style;
}
/**
* Get the namespace for schema definitions. This value must be set by subclasses using the
* {@link #setNamespace(String)} method.
*
* @return schema namespace
*/
public final String getNamespace() {
return m_actualNamespace;
}
/**
* Set the namespace to be used for schema definitions. This method is only intended for use by subclasses.
*
* @param ns
*/
protected void setNamespace(String ns) {
m_actualNamespace = ns;
}
/**
* Check if primitive value should be treated as required. If not set at any nesting level, the default is
* true.
*
* @param type primitive type
* @return true if required value, false if not
*/
public boolean isPrimitiveRequired(String type) {
if (m_require == null) {
if (getParent() == null) {
return true;
} else {
return getParent().isPrimitiveRequired(type);
}
} else {
return m_require.intValue() == REQUIRE_ALL || m_require.intValue() == REQUIRE_PRIMITIVES;
}
}
/**
* Check if object value should be treated as required. If not set at any nesting level, the default is
* false.
*
* @param type object type
* @return true if required value, false if not
*/
public boolean isObjectRequired(String type) {
if (m_require == null) {
if (getParent() == null) {
return false;
} else {
return getParent().isObjectRequired(type);
}
} else {
return m_require.intValue() == REQUIRE_ALL || m_require.intValue() == REQUIRE_OBJECTS;
}
}
/**
* Check if JavaDocs should be used for documentation. If not set at any nesting level, the default is
* true.
*
* @return force names flag
*/
public boolean isUseJavaDocs() {
if (m_useJavaDocs == null) {
if (getParent() == null) {
return true;
} else {
return getParent().isUseJavaDocs();
}
} else {
return m_useJavaDocs.booleanValue();
}
}
/**
* Convert class or unprefixed field name to element or attribute name using current format.
*
* @param base class or simple field name to be converted
* @return element or attribute name
*/
public String convertName(String base) {
return convertName(base, getNameStyle());
}
/**
* Name style set text method. This is intended for use during unmarshalling. TODO: add validation
*
* @param text
* @param ictx
*/
private void setNameStyleText(String text, IUnmarshallingContext ictx) {
if (text == null) {
m_nameStyle = null;
} else {
m_nameStyle = new Integer(s_nameStyleEnum.getValue(text));
}
}
/**
* Name style get text method. This is intended for use during marshalling.
*
* @return text
*/
private String getNameStyleText() {
if (m_nameStyle == null) {
return null;
} else {
return s_nameStyleEnum.getName(m_nameStyle.intValue());
}
}
/**
* Namespace style set text method. This is intended for use during unmarshalling. TODO: add validation
*
* @param text
* @param ictx
*/
private void setNamespaceStyleText(String text, IUnmarshallingContext ictx) {
if (text == null) {
m_namespaceStyle = null;
} else {
m_namespaceStyle = new Integer(s_namespaceStyleEnum.getValue(text));
}
}
/**
* Namespace style get text method. This is intended for use during marshalling.
*
* @return text
*/
private String getNamespaceStyleText() {
if (m_namespaceStyle == null) {
return null;
} else {
return s_namespaceStyleEnum.getName(m_namespaceStyle.intValue());
}
}
/**
* Required set text method. This is intended for use during unmarshalling. TODO: add validation
*
* @param text
* @param ictx
*/
private void setRequireText(String text, IUnmarshallingContext ictx) {
if (text == null) {
m_require = null;
} else {
m_require = new Integer(s_requireEnum.getValue(text));
}
}
/**
* Required get text method. This is intended for use during marshalling.
*
* @return text
*/
private String getRequireText() {
if (m_require == null) {
return null;
} else {
return s_requireEnum.getName(m_require.intValue());
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/PackageCustom.java 0000644 0001750 0001750 00000013176 11062041242 026207 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom.classes;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.util.IClassLocator;
import org.jibx.util.StringArray;
/**
* Package customization information.
*
* @author Dennis M. Sosnoski
*/
public class PackageCustom extends NestingBase implements IApply
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "name" }, NestingBase.s_allowedAttributes);
/** Element name in XML customization file. */
public static final String ELEMENT_NAME = "package";
// values specific to package level
private String m_simpleName;
private String m_fullName;
// flag for namespace derivation done (from apply() method)
private boolean m_fixedNamespace;
// map from simple name to class information for classes in package
private Map m_classMap;
/**
* Constructor. This has package access so that it can be used from the {@link GlobalCustom} class.
*
* @param simple simple package name
* @param full fully-qualified package name
* @param parent
*/
/* package */PackageCustom(String simple, String full, NestingBase parent) {
super(parent);
m_simpleName = simple;
m_fullName = full;
m_classMap = new HashMap();
}
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
*/
private void preSet(IUnmarshallingContext uctx) {
validateAttributes(uctx, s_allowedAttributes);
}
/**
* Get fully-qualified package name.
*
* @return package name (empty string if default package)
*/
public String getName() {
return m_fullName;
}
/**
* Get existing information for class in this package.
*
* @param name simple class name (without package)
* @return class information (null if no existing information)
*/
public ClassCustom getClassCustomization(String name) {
return (ClassCustom)m_classMap.get(name);
}
/**
* Add information for class in this package. This just creates the basic class information structure and returns
* it, without populating the class details.
*
* @param name simple class name (without package)
* @return class information (null if no existing information)
*/
/* package */ClassCustom addClassCustomization(String name) {
ClassCustom clas = new ClassCustom(this, name);
m_classMap.put(name, clas);
return clas;
}
/**
* Fix the namespace for this package. If there's a parent package and that package namespace has not yet been
* fixed, this first fixes the parent package namespace by means of a recursive call.
*/
public void fixNamespace() {
if (!m_fixedNamespace) {
// first fix parent package namespace
SharedNestingBase parent = getParent();
if (parent instanceof PackageCustom) {
((PackageCustom)parent).fixNamespace();
}
// derive namespace from parent setting, if not specified
String ns = getSpecifiedNamespace();
if (ns == null) {
String pns = parent.getNamespace();
ns = deriveNamespace(pns, m_fullName, getNamespaceStyle());
}
setNamespace(ns);
m_fixedNamespace = true;
}
}
/**
* Apply customizations to default values. This fills in the information for classes in this package by deriving
* information for fields or properties in each class. This is intended to be used once, after customizations have
* been unmarshalled.
*
* @param loc class locator
*/
public void apply(IClassLocator loc) {
// apply customizations for all contained classes
for (Iterator iter = m_classMap.values().iterator(); iter.hasNext();) {
((ClassCustom)iter.next()).apply(loc);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/SharedValueBase.java 0000644 0001750 0001750 00000030003 11311541456 026454 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom.classes;
import org.jibx.binding.classes.ClassItem;
import org.jibx.util.IClass;
import org.jibx.util.StringArray;
/**
* Base class for all value customization information. This includes inherited values shared with customization
* extensions (in particular, the WSDL extensions).
*
* TODO: should this include more of the WSDL ValueCustom extensions? Look into how type mappings are handled in the
* BindGen code (uses bound type in WSDL)
*
* @author Dennis M. Sosnoski
*/
public class SharedValueBase extends CustomBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "actual-type", "create-type", "factory", "item-name", "item-type", "required" });
//
// Internal instance data
/** Value name as used in code. */
private String m_baseName;
/** Element representation forced flag. */
private boolean m_elementForced;
/** Stated type, as used in code. */
private String m_statedType;
/** Type used when working with the value (actual type from customization, if supplied, or stated type). */
private String m_workingType;
/** Type of item values in collection. */
private String m_itemWorkingType;
/** Name for item elements in collection. */
private String m_itemWorkingName;
/** Primitive value flag. */
private boolean m_primitive;
/** Repeated value flag. */
private boolean m_collection;
//
// Values handled by binding
/** Style used for representation (null if unspecified and derived from type). */
private Integer m_style;
/** Element or attribute name from customization (null if none). */
private String m_xmlName;
/** 'actual-type' attribute value (null if none). */
private String m_actualType;
/** 'create-type' attribute value (null if none). */
private String m_createType;
/** 'factory' attribute value (null if none). */
private String m_factoryMethod;
/** 'required' attribute value (null if none). */
private Boolean m_required;
/** 'item-type' attribute value (null if none). */
private String m_itemType;
/** 'item-name' attribute value (null if none). */
private String m_itemName;
/**
* Constructor.
*
* @param parent
*/
protected SharedValueBase(SharedNestingBase parent) {
super(parent);
}
/**
* Constructor with name known.
*
* @param parent
* @param name
*/
protected SharedValueBase(SharedNestingBase parent, String name) {
this(parent);
m_baseName = name;
}
/**
* Convenience method to access the containing class customization element.
*
* @return class customization
*/
public ClassCustom getClassCustom() {
return (ClassCustom)getParent();
}
/**
* Get value name as used in code. This is the actual name with any prefix or suffix stripped and the initial letter
* converted to lowercase unless the second letter is uppercase.
*
* @return name
*/
public String getBaseName() {
return m_baseName;
}
/**
* Set value name as used in code. This is only for use by subclasses.
*
* @param name
* @see SharedValueBase#getBaseName()
*/
protected void setBaseName(String name) {
m_baseName = name;
}
/**
* Get stated type of value, as declared in code.
*
* @return stated type
*/
public String getStatedType() {
return m_statedType;
}
/**
* Get working type of member. This is the actual type from customization, if supplied, or stated type
*
* @return working type
*/
public String getWorkingType() {
return m_workingType;
}
/**
* Convert case of member name derived from name used in code. If the supplied name starts with an uppercase letter
* followed by a lowercase letter, the initial letter is converted to lowercase in order to obtain a standard form
* of the name.
*
* @param name
* @return converted name
*/
public static String convertMemberNameCase(String name) {
if (name.length() > 0) {
char lead = name.charAt(0);
if (name.length() > 1) {
if (Character.isUpperCase(lead) && Character.isLowerCase(name.charAt(1))) {
StringBuffer buff = new StringBuffer(name);
buff.setCharAt(0, Character.toLowerCase(lead));
name = buff.toString();
}
} else {
name = name.toLowerCase();
}
}
return name;
}
/**
* Get style code to apply to value.
*
* @return value from {@link NestingBase#s_valueStyleEnum} enumeration
*/
public int getStyle() {
if (m_style == null) {
return ((NestingBase)getParent()).getValueStyle(m_workingType);
} else {
return m_style.intValue();
}
}
/**
* Set style code to apply to value. This method is only intended for use by subclasses.
*
* @param style
*/
protected void setStyle(Integer style) {
m_style = style;
}
/**
* Get XML element or attribute name from customization.
*
* @return name (null if none)
*/
public String getXmlName() {
return m_xmlName;
}
/**
* Set XML element or attribute name from customization. This method is only intended for use by subclasses.
*
* @param name
*/
public void setXmlName(String name) {
m_xmlName = name;
}
/**
* Get 'actual-type' attribute value.
*
* @return member actual type (null if none)
*/
public String getActualType() {
return m_actualType;
}
/**
* Get 'create-type' attribute value.
*
* @return type used for creating new instance (null if none)
*/
public String getCreateType() {
return m_createType;
}
/**
* Get 'factory' attribute value.
*
* @return method used for creating new instance (null if none)
*/
public String getFactoryMethod() {
return m_factoryMethod;
}
/**
* Check if value is required.
*
* @return true if required, false if not
*/
public boolean isRequired() {
if (m_required == null) {
if (m_primitive) {
return getParent().isPrimitiveRequired(m_workingType);
} else {
return getParent().isObjectRequired(m_workingType);
}
} else {
return m_required.booleanValue();
}
}
/**
* Check if element required. This is really only relevant when the value represents a collection of child elements,
* since it means a wrapper element is needed.
*
* @return true if element required, false if not
*/
public boolean isElementForced() {
return m_elementForced;
}
/**
* Set element required. This method is only intended for use by subclasses.
*/
protected void setElementForced() {
m_elementForced = true;
}
/**
* Style get text method. This is intended for use during marshalling. TODO: add validation
*
* @return text
*/
private String getStyleText() {
if (m_style == null) {
return null;
} else {
return NestingBase.s_valueStyleEnum.getName(m_style.intValue());
}
}
/**
* Check if collection member.
*
* @return true if collection, false if not
*/
public boolean isCollection() {
return m_collection;
}
/**
* Get item type.
*
* @return item type
*/
public String getItemType() {
return m_itemWorkingType;
}
/**
* Set item type. This method is intended only for use by subclasses.
*
* @param type
*/
protected void setItemType(String type) {
m_itemWorkingType = type;
}
/**
* Get item element name.
*
* @return item name
*/
public String getItemName() {
return m_itemWorkingName;
}
/**
* Set item name. This method is intended only for use by subclasses.
*
* @param name
*/
protected void setItemName(String name) {
m_itemWorkingName = name;
}
/**
* Complete customization information based on supplied type. If the type information has not previously been set,
* this will set it. It will also derive the appropriate XML name, if not previously set. This method is only
* intended for use by subclasses.
*
* @param info value type information
* @param req required member flag (null if unspecified)
* @param style representation style (null if unspecified)
*/
protected void fillType(IClass info, Boolean req, Integer style) {
String type = info.getName();
m_statedType = type;
if (m_actualType == null) {
m_workingType = type;
} else {
m_workingType = m_actualType;
}
if (m_xmlName == null) {
m_xmlName = getParent().convertName(m_baseName);
}
m_collection = type.endsWith("[]") || info.isImplements("Ljava/util/Collection;");
m_primitive = ClassItem.isPrimitive(m_workingType);
// TODO: check consistency of setting
if (m_required == null) {
m_required = req;
}
if (m_style == null) {
m_style = style;
if (style != null && style.intValue() == NestingBase.ELEMENT_VALUE_STYLE) {
m_elementForced = true;
}
}
if (!m_primitive && m_createType == null && m_factoryMethod == null) {
ClassCustom cust = getGlobal().getClassCustomization(m_workingType);
if (cust != null) {
m_createType = cust.getCreateType();
m_factoryMethod = cust.getFactoryMethod();
}
}
if (isCollection()) {
m_itemWorkingType = m_itemType;
m_itemWorkingName = m_itemName;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/ClassItemSourceWrapper.java 0000644 0001750 0001750 00000021204 11305426500 030062 0 ustar twerner twerner /*
* Copyright (c) 2004-2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom.classes;
import org.jibx.binding.classes.ClassItem;
import org.jibx.binding.model.ClassItemWrapper;
import org.jibx.util.IClass;
import org.jibx.util.IClassLocator;
import com.thoughtworks.qdox.model.DocletTag;
import com.thoughtworks.qdox.model.JavaClass;
import com.thoughtworks.qdox.model.JavaField;
import com.thoughtworks.qdox.model.JavaMethod;
import com.thoughtworks.qdox.model.JavaParameter;
import com.thoughtworks.qdox.model.Member;
import com.thoughtworks.qdox.model.Type;
/**
* Wrapper for class field or method item with added source information. This wraps the basic class handling
* implementation with added support for retrieving information from source files.
*
* @author Dennis M. Sosnoski
*/
public class ClassItemSourceWrapper extends ClassItemWrapper
{
private boolean m_checkedSource;
private Member m_itemSource;
/**
* Constructor
*
* @param clas
* @param item
*/
/* package */ClassItemSourceWrapper(IClass clas, ClassItem item) {
super(clas, item);
}
/**
* Check for source method signature match.
*
* @param method
* @return true if match to this method, false if not
*/
private boolean matchSignature(JavaMethod method) {
boolean match = true;
JavaParameter[] parms = method.getParameters();
if (parms.length == getArgumentCount()) {
for (int j = 0; j < parms.length; j++) {
Type ptype = parms[j].getType();
String type = ptype.getValue();
int ndim = ptype.getDimensions();
while (ndim-- > 0) {
type += "[]";
}
String comp = getArgumentType(j);
if (!comp.equals(type)) {
if (type.indexOf('.') >= 0 || !comp.endsWith('.' + type)) {
match = false;
break;
}
}
}
}
return match;
}
/**
* Internal method to get the source code information for this item.
*
* @return source information
*/
private Member getItemSource() {
if (!m_checkedSource) {
m_checkedSource = true;
IClass clas = getContainingClass();
IClassLocator loc = clas.getLocator();
if (loc instanceof IClassSourceLocator) {
IClassSourceLocator sloc = (IClassSourceLocator)loc;
JavaClass jc = sloc.getSourceInfo(clas.getName());
if (jc != null) {
if (isMethod()) {
String mname = getName();
JavaMethod[] methods = jc.getMethods();
for (int i = 0; i < methods.length; i++) {
JavaMethod method = methods[i];
if (mname.equals(method.getName())) {
if (matchSignature(method)) {
m_itemSource = method;
break;
}
}
}
} else {
m_itemSource = jc.getFieldByName(getName());
}
}
}
}
return m_itemSource;
}
/**
* Return JavaDoc text only if non-empty.
*
* @param text raw JavaDoc text
* @return trimmed text if non-empty, otherwise null
*/
private static String docText(String text) {
if (text != null) {
text = text.trim();
if (text.length() > 0) {
return text;
}
}
return null;
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.model.IClassItem#getJavaDoc()
*/
public String getJavaDoc() {
Member src = getItemSource();
if (src == null) {
return null;
} else if (isMethod()) {
return docText(((JavaMethod)src).getComment());
} else {
return docText(((JavaField)src).getComment());
}
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.model.IClassItem#getReturnJavaDoc()
*/
public String getReturnJavaDoc() {
if (isMethod()) {
JavaMethod jm = (JavaMethod)getItemSource();
if (jm != null) {
DocletTag tag = jm.getTagByName("return");
if (tag != null) {
return docText(tag.getValue());
}
}
return null;
} else {
throw new IllegalStateException("Internal error: not a method");
}
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.model.IClassItem#getParameterJavaDoc(int)
*/
public String getParameterJavaDoc(int index) {
if (isMethod()) {
JavaMethod jm = (JavaMethod)getItemSource();
if (jm != null) {
String name = jm.getParameters()[index].getName();
DocletTag[] tags = jm.getTagsByName("param");
for (int i = 0; i < tags.length; i++) {
DocletTag tag = tags[i];
String[] parms = tag.getParameters();
if (parms != null && parms.length > 0 && name.equals(parms[0])) {
String text = tag.getValue().trim();
if (text.startsWith(name)) {
text = text.substring(name.length()).trim();
}
return docText(text);
}
}
}
return null;
} else {
throw new IllegalStateException("Internal error: not a method");
}
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.model.IClassItem#getParameterName(int)
*/
public String getParameterName(int index) {
JavaMethod jm = (JavaMethod)getItemSource();
String name;
if (jm != null) {
JavaParameter[] parameters = jm.getParameters();
name = parameters[index].getName();
} else {
name = super.getParameterName(index);
}
return name;
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.model.IClassItem#getExceptionJavaDoc(int)
*/
public String getExceptionJavaDoc(int index) {
if (isMethod()) {
JavaMethod jm = (JavaMethod)getItemSource();
if (jm != null) {
String name = getExceptions()[index];
DocletTag[] tags = jm.getTagsByName("throws");
for (int i = 0; i < tags.length; i++) {
DocletTag tag = tags[i];
String[] parms = tag.getParameters();
if (parms != null && parms.length > 0 && name.equals(parms[0])) {
return docText(tag.getValue());
}
}
}
return null;
} else {
throw new IllegalStateException("Internal error: not a method");
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/NestingBase.java 0000644 0001750 0001750 00000021131 11256241372 025664 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom.classes;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.Utility;
import org.jibx.util.StringArray;
import org.jibx.util.Types;
/**
* Base class for all standard binding customizations that can contain other customizations.
*
* @author Dennis M. Sosnoski
*/
public abstract class NestingBase extends SharedNestingBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "force-mapping", "force-names", "map-abstract", "property-access",
"strip-prefixes", "strip-suffixes", "value-style", "wrap-collections" },
SharedNestingBase.s_allowedAttributes);
// value style value set information
public static final int ATTRIBUTE_VALUE_STYLE = 0;
public static final int ELEMENT_VALUE_STYLE = 1;
public static final Integer ATTRIBUTE_STYLE_INTEGER = new Integer(ATTRIBUTE_VALUE_STYLE);
public static final Integer ELEMENT_STYLE_INTEGER = new Integer(ELEMENT_VALUE_STYLE);
public static final EnumSet s_valueStyleEnum =
new EnumSet(ATTRIBUTE_VALUE_STYLE, new String[] { "attribute", "element" });
// values inherited through nesting
private Integer m_valueStyle;
private Boolean m_propertyAccess;
private String[] m_stripPrefixes;
private String[] m_stripSuffixes;
private Boolean m_mapAbstract;
private Boolean m_wrapCollections;
private Boolean m_forceMapping;
private Boolean m_forceNames;
/**
* Constructor.
*
* @param parent
*/
public NestingBase(SharedNestingBase parent) {
super(parent);
}
//
// Access methods for values inherited through nesting
/**
* Check abstract mapping flag. If not set at any nesting level, the default is true.
*
* @return abstract mapping flag
*/
public boolean isMapAbstract() {
if (m_mapAbstract == null) {
if (getParent() == null) {
return true;
} else {
return ((NestingBase)getParent()).isMapAbstract();
}
} else {
return m_mapAbstract.booleanValue();
}
}
/**
* Set abstract mapping flag.
*
* @param abs
*/
public void setMapAbstract(Boolean abs) {
m_mapAbstract = abs;
}
/**
* Check force mapping flag. If not set at any nesting level, the default is false.
*
* @return force mapping flag
*/
public boolean isForceMapping() {
if (m_forceMapping == null) {
if (getParent() == null) {
return false;
} else {
return ((NestingBase)getParent()).isForceMapping();
}
} else {
return m_forceMapping.booleanValue();
}
}
/**
* Check force structure names flag. If not set at any nesting level, the default is true.
*
* @return force names flag
*/
public boolean isForceStructureNames() {
if (m_forceNames == null) {
if (getParent() == null) {
return true;
} else {
return ((NestingBase)getParent()).isForceStructureNames();
}
} else {
return m_forceNames.booleanValue();
}
}
/**
* Check wrap collections flag. If not set at any nesting level, the default is false.
*
* @return wrap collections flag
*/
public boolean isWrapCollections() {
if (m_wrapCollections == null) {
if (getParent() == null) {
return false;
} else {
return ((NestingBase)getParent()).isWrapCollections();
}
} else {
return m_wrapCollections.booleanValue();
}
}
/**
* Check property access mode flag. If not set at any nesting level, the default is false.
*
* @return true if bean-style get/set methods to be used, false if fields to be used
* directly
*/
public boolean isPropertyAccess() {
if (m_propertyAccess == null) {
if (getParent() == null) {
return false;
} else {
return ((NestingBase)getParent()).isPropertyAccess();
}
} else {
return m_propertyAccess.booleanValue();
}
}
/**
* Get prefixes to be stripped from field names.
*
* @return strip prefixes (null if none)
*/
public String[] getStripPrefixes() {
if (m_stripPrefixes == null) {
if (getParent() == null) {
return Utility.EMPTY_STRING_ARRAY;
} else {
return ((NestingBase)getParent()).getStripPrefixes();
}
} else {
return m_stripPrefixes;
}
}
/**
* Get suffixes to be stripped from field names.
*
* @return strip suffix (null if none)
*/
public String[] getStripSuffixes() {
if (m_stripSuffixes == null) {
if (getParent() == null) {
return Utility.EMPTY_STRING_ARRAY;
} else {
return ((NestingBase)getParent()).getStripSuffixes();
}
} else {
return m_stripSuffixes;
}
}
/**
* Get value style code.
*
* @param type value type name
* @return value from {@link NestingBase#s_valueStyleEnum} enumeration
*/
public int getValueStyle(String type) {
if (m_valueStyle == null) {
if (getParent() == null) {
if (!"java.lang.String".equals(type) && !"byte[]".equals(type) && Types.isSimpleValue(type)) {
return ATTRIBUTE_VALUE_STYLE;
} else {
return ELEMENT_VALUE_STYLE;
}
} else {
return ((NestingBase)getParent()).getValueStyle(type);
}
} else {
return m_valueStyle.intValue();
}
}
/**
* Set value style.
*
* @param style (null if none at this level)
*/
public void setValueStyle(Integer style) {
m_valueStyle = style;
}
/**
* Value style set text method. This is intended for use during unmarshalling. TODO: add validation
*
* @param text
* @param ictx
*/
private void setValueStyleText(String text, IUnmarshallingContext ictx) {
if (text == null) {
m_valueStyle = null;
} else {
m_valueStyle = new Integer(s_valueStyleEnum.getValue(text));
}
}
/**
* Value style get text method. This is intended for use during marshalling.
*
* @return text
*/
private String getValueStyleText() {
if (m_valueStyle == null) {
return null;
} else {
return s_valueStyleEnum.getName(m_valueStyle.intValue());
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/ClassCustom.java 0000644 0001750 0001750 00000074357 11256240642 025743 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom.classes;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.jibx.custom.CustomUtils;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.QName;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
import org.jibx.util.IClassLocator;
import org.jibx.util.InsertionOrderedMap;
import org.jibx.util.InsertionOrderedSet;
import org.jibx.util.StringArray;
/**
* Class customization information. This supports direct class customizations (such as the corresponding element name,
* when building a concrete mapping) and also acts as a container for individual fields and/or properties.
*
* @author Dennis M. Sosnoski
*/
public class ClassCustom extends NestingBase implements IApply
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "create-type", "deserializer", "element-name", "enum-value-method", "excludes",
"factory", "form", "includes", "name", "optionals", "requireds", "serializer", "type-name", "use-super" },
NestingBase.s_allowedAttributes);
/** Element name in XML customization file. */
public static final String ELEMENT_NAME = "class";
// value set information
public static final int FORM_DEFAULT = 0;
public static final int FORM_CONCRETE_MAPPING = 1;
public static final int FORM_ABSTRACT_MAPPING = 2;
public static final int FORM_STRING = 3;
public static final EnumSet s_representationEnum =
new EnumSet(FORM_DEFAULT, new String[] { "default", "concrete-mapping", "abstract-mapping", "simple" });
// values specific to class level
private String m_name;
private String m_elementName;
private String m_typeName;
private String m_createType;
private String m_factoryMethod;
private String m_enumValueMethod;
private int m_form;
private String[] m_includes;
private String[] m_excludes;
private boolean m_useSuper;
private String[] m_requireds;
private String[] m_optionals;
private String m_serializer;
private String m_deserializer;
// list of contained items
private final ArrayList m_children;
// values filled in by apply() method
private boolean m_isApplied;
private QName m_typeQName;
private QName m_elementQName;
private IClass m_classInformation;
private InsertionOrderedMap m_memberMap;
/**
* Constructor.
*
* @param parent
* @param name class simple name (without package)
*/
/* package */ClassCustom(NestingBase parent, String name) {
super(parent);
m_name = name;
m_children = new ArrayList();
m_useSuper = true;
m_form = -1;
}
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
*/
private void preSet(IUnmarshallingContext uctx) {
validateAttributes(uctx, s_allowedAttributes);
}
/**
* Get fully-qualified class name.
*
* @return class name
*/
public String getName() {
PackageCustom parent = (PackageCustom)getParent();
String pack = parent.getName();
if (pack.length() > 0) {
return pack + '.' + m_name;
} else {
return m_name;
}
}
/**
* Get simple class name.
*
* @return class name
*/
public String getSimpleName() {
return m_name;
}
/**
* Get the element name to be used for this class in a concrete mapping.
*
* @return element name
*/
public String getElementName() {
return m_elementName;
}
/**
* Get the qualified element name to be used for this class in a concrete mapping.
*
* @return element name
*/
public QName getElementQName() {
return m_elementQName;
}
/**
* Get the type name to be used for this class in an abstract mapping.
*
* @return type name
*/
public String getTypeName() {
return m_typeName;
}
/**
* Get the type name to be used when creating an instance of this class.
*
* @return type name
*/
public String getCreateType() {
return m_createType;
}
/**
* Set the type name to be used when creating an instance of this class.
*
* @param type
*/
public void setCreateType(String type) {
m_createType = type;
}
/**
* Get serializer method.
*
* @return serializer
*/
public String getSerializer() {
return m_serializer;
}
/**
* Get deserializer method.
*
* @return deserializer
*/
public String getDeserializer() {
return m_deserializer;
}
/**
* Get the method used to retrieve the text value for an enum class.
*
* @return method name
*/
public String getEnumValueMethod() {
return m_enumValueMethod;
}
/**
* Get the factory method to be used when creating an instance of this class.
*
* @return method name
*/
public String getFactoryMethod() {
return m_factoryMethod;
}
/**
* Get the qualified type name to be used for this class in an abstract mapping.
*
* @return type qname
*/
public QName getTypeQName() {
return m_typeQName;
}
/**
* Get the representation code.
*
* @return value from {@link #s_representationEnum} enumeration
*/
public int getForm() {
return m_form;
}
/**
* Get list of names to be excluded from class representation.
*
* @return excludes (null if none)
*/
public String[] getExcludes() {
return m_excludes;
}
/**
* Get list of names to be included in class representation.
*
* @return includes (null if none)
*/
public String[] getIncludes() {
return m_includes;
}
/**
* Check for superclass to be included in binding.
*
* @return true if superclass included, false if not
*/
public boolean isUseSuper() {
return m_useSuper;
}
/**
* Check if this is a directly instantiable class (not an interface, and not abstract)
*
* @return true if instantiable, false if not
*/
public boolean isConcreteClass() {
return !(m_classInformation.isAbstract() || m_classInformation.isInterface());
}
/**
* Check if class represents a simple text value.
*
* @return text value flag
*/
public boolean isSimpleValue() {
return m_form == FORM_STRING;
}
/**
* Check if abstract mapping required for class.
*
* @return abstract mapping flag
*/
public boolean isAbstractMappingForced() {
return m_form == FORM_ABSTRACT_MAPPING;
}
/**
* Check if concrete mapping required for class. If a 'form' setting is defined for the class it returns the flag
* based on that setting, and otherwise returns based on the nesting abstract mapping flag.
*
* @return abstract mapping flag
*/
public boolean isConcreteMappingForced() {
return m_form == FORM_CONCRETE_MAPPING;
}
/**
* Get list of children.
*
* @return list
*/
public List getChildren() {
return m_children;
}
/**
* Add child.
*
* @param child
*/
protected void addChild(CustomBase child) {
if (child.getParent() == this) {
m_children.add(child);
} else {
throw new IllegalStateException("Internal error: child not linked");
}
}
/**
* Form set text method. This is intended for use during unmarshalling. TODO: add validation
*
* @param text
* @param ictx
*/
private void setFormText(String text, IUnmarshallingContext ictx) {
m_form = s_representationEnum.getValue(text);
}
/**
* Form get text method. This is intended for use during marshalling.
*
* @return text
*/
private String getFormText() {
return s_representationEnum.getName(m_form);
}
/**
* Build map from member names to read access methods. This assumes that each public, non-static, no-argument
* method which returns a value and has a name beginning with "get" or "is" is a property read access method. It
* maps the corresponding property name to the method, and returns the map.
*
* @param methods
* @param inclset set of member names to be included (null if not specified)
* @param exclset set of member names to be excluded (null if not specified, ignored if inclset is
* non-null)
* @return map
*/
private Map mapPropertyReadMethods(IClassItem[] methods, Set inclset, Set exclset) {
// check all methods for property read access matches
InsertionOrderedMap getmap = new InsertionOrderedMap();
for (int i = 0; i < methods.length; i++) {
IClassItem item = methods[i];
String name = item.getName();
int flags = item.getAccessFlags();
if (item.getArgumentCount() == 0 && (flags & Modifier.STATIC) == 0 && (flags & Modifier.PUBLIC) != 0 &&
((name.startsWith("get") && !item.getTypeName().equals("void")) || (name.startsWith("is") &&
item.getTypeName().equals("boolean")))) {
// have what appears to be a getter, check if it should be used
String memb = ValueCustom.memberNameFromGetMethod(name);
boolean use = true;
if (inclset != null) {
use = inclset.contains(memb.toLowerCase());
} else if (exclset != null) {
use = !exclset.contains(memb.toLowerCase());
}
if (use) {
getmap.put(memb, item);
}
}
}
return getmap;
}
/**
* Build map from member names to write access methods. This assumes that each public, non-static, single-argument
* method which returns void and has a name beginning with "set" is a property write access method. It maps the
* corresponding property name to the method, and returns the map.
*
* @param methods
* @param inclset set of member names to be included (null if not specified)
* @param exclset set of member names to be excluded (null if not specified, ignored if inclset is
* non-null)
* @return map
*/
private Map mapPropertyWriteMethods(IClassItem[] methods, Set inclset, Set exclset) {
// check all methods for property write access matches
InsertionOrderedMap setmap = new InsertionOrderedMap();
for (int i = 0; i < methods.length; i++) {
IClassItem item = methods[i];
String name = item.getName();
int flags = item.getAccessFlags();
if (item.getArgumentCount() == 1 && (flags & Modifier.STATIC) == 0 && (flags & Modifier.PUBLIC) != 0 &&
name.startsWith("set") && item.getTypeName().equals("void")) {
// have what appears to be a setter, check if it should be used
String memb = ValueCustom.memberNameFromSetMethod(name);
boolean use = true;
if (inclset != null) {
use = inclset.contains(memb.toLowerCase());
} else if (exclset != null) {
use = !exclset.contains(memb.toLowerCase());
}
if (use) {
setmap.put(memb, item);
}
}
}
return setmap;
}
/**
* Build map from member names to fields. This includes all non-static and non-transient fields of the class.
*
* @param fields
* @param prefs prefixes to be stripped in deriving names
* @param suffs suffixes to be stripped in deriving names
* @param inclset set of member names to be included (null if not specified)
* @param exclset set of member names to be excluded (null if not specified, ignored if inclset is
* non-null)
* @return map
*/
private Map mapFields(IClassItem[] fields, String[] prefs, String[] suffs, Set inclset, Set exclset) {
// check all fields for use as members
InsertionOrderedMap fieldmap = new InsertionOrderedMap();
for (int i = 0; i < fields.length; i++) {
IClassItem item = fields[i];
if ((item.getAccessFlags() & (Modifier.FINAL | Modifier.STATIC | Modifier.TRANSIENT)) == 0) {
// not final, static, or transient, so check if it should be used
String name = item.getName();
String memb = ValueCustom.memberNameFromField(name, prefs, suffs);
boolean use = true;
if (inclset != null) {
use = inclset.contains(memb.toLowerCase());
} else if (exclset != null) {
use = !exclset.contains(memb.toLowerCase());
}
if (use) {
fieldmap.put(memb, item);
}
}
}
return fieldmap;
}
/**
* Find the most specific type for a property based on the access methods.
*
* @param gmeth read access method (null if not defined)
* @param smeth write access method (null if not defined)
* @param icl
* @return most specific type name
*/
private String findPropertyType(IClassItem gmeth, IClassItem smeth, IClassLocator icl) {
String type;
if (gmeth == null) {
if (smeth == null) {
throw new IllegalArgumentException("Internal error: no access methods known");
} else {
type = smeth.getArgumentType(0);
}
} else if (smeth == null) {
type = gmeth.getTypeName();
} else {
String gtype = gmeth.getTypeName();
String stype = smeth.getArgumentType(0);
IClass gclas = icl.getRequiredClassInfo(gtype);
if (gclas.isSuperclass(stype) || gclas.isImplements(stype)) {
type = gtype;
} else {
type = stype;
}
}
return type;
}
/**
* Utility method to strip any leading non-alphanumeric characters from an array of name strings.
*
* @param names (null if none)
* @return array of stripped names (null if none)
*/
private static String[] stripNames(String[] names) {
if (names == null) {
return null;
} else {
String[] strips = null;
for (int i = 0; i < names.length; i++) {
String name = names[i];
int index = 0;
while (index < name.length()) {
char chr = name.charAt(index);
if (Character.isLetter(chr) || Character.isDigit(chr)) {
break;
} else {
index++;
}
}
if (index > 0) {
if (strips == null) {
strips = new String[names.length];
System.arraycopy(names, 0, strips, 0, names.length);
}
strips[i] = name.substring(index);
}
}
return (strips == null) ? names : strips;
}
}
/**
* Classify an array of names as elements or attributes, based on leading flag characters ('@' for an attribute,
* '<' for an element).
*
* @param names (null if none)
* @param elems set of element names
* @param attrs set of attribute names
*/
private static void classifyNames(String[] names, Set elems, Set attrs) {
if (names != null) {
for (int i = 0; i < names.length; i++) {
String name = names[i];
if (name.length() > 0) {
char chr = name.charAt(0);
Set addset = null;
Set altset = null;
if (chr == '@') {
addset = attrs;
altset = elems;
} else if (chr == '/') {
addset = elems;
altset = attrs;
}
if (addset != null) {
name = name.substring(1).toLowerCase();
addset.add(name);
if (altset.contains(name)) {
throw new IllegalArgumentException("Name " + name + " used as both element and attribute");
}
}
}
}
}
}
/**
* Apply customizations to class to fill out members. The name handling gets tricky, because of the variety of
* options provided. The user can specify value names to be included and/or excluded for the class, and also value
* names to be treated as optional or required. If an 'includes' list is given, only the values on that list are
* processed from the class, along with any values with their own child elements. If an 'excludes' list is given,
* only the names not on that list are processed. If neither an 'includes' nor an 'excludes' list is present, all
* values defined by the class will be processed. It is an error if the same name occurs on both an 'excludes' list
* and any other list, or if a name on the 'excludes' list has a child element present. It is also an error if the
* same name occurs on both the 'optionals' and 'requireds' list. Each list name can also be flagged with a leading
* indicator character to say whether the value should be represented as an attribute ('@') or element ('<'). The
* order of child elements is also partially determined by the lists, with the 'includes' list processed first, then
* the 'requireds' list, then the 'optionals' list, then the child elements, then any values not yet processed.
*
* @param icl class locator
*/
public void apply(IClassLocator icl) {
// check for repeated call (happens due to package-level apply()
if (m_isApplied) {
return;
}
m_isApplied = true;
// initialize class information
m_classInformation = icl.getClassInfo(getName());
if (m_classInformation == null) {
throw new IllegalStateException("Internal error: unable to find class " + m_name);
}
// skip any member handling if simple value
if (m_form == FORM_STRING) {
return;
}
// inherit namespace directly from package level, if not specified
String ns = getSpecifiedNamespace();
if (ns == null) {
ns = getParent().getNamespace();
}
setNamespace(ns);
// set the name(s) to be used if mapped
String cname = convertName(getSimpleName());
if (m_elementName == null) {
m_elementName = cname;
}
m_elementQName = new QName(getNamespace(), m_elementName);
if (m_typeName == null) {
m_typeName = cname;
}
m_typeQName = new QName(getNamespace(), m_typeName);
// initialize maps with existing member customizations
HashMap namemap = new HashMap();
for (Iterator iter = getChildren().iterator(); iter.hasNext();) {
ValueCustom memb = (ValueCustom)iter.next();
String name = memb.getBaseName();
if (name != null) {
namemap.put(name, memb);
}
}
// generate sets of names to be included or ignored, and optional/requires, elements/attributes
InsertionOrderedSet nameset = new InsertionOrderedSet();
Set exclset = null;
Set inclset = null;
Set elemset = Collections.EMPTY_SET;
Set attrset = Collections.EMPTY_SET;
Set optset = Collections.EMPTY_SET;
Set reqset = Collections.EMPTY_SET;
if (m_includes != null || m_optionals != null || m_requireds != null) {
// initialize the ordered set of names to be included
String[] optionals = stripNames(m_optionals);
String[] requireds = stripNames(m_requireds);
if (m_includes != null) {
nameset.addAll(stripNames(m_includes));
} else {
if (requireds != null) {
nameset.addAll(requireds);
}
if (optionals != null) {
nameset.addAll(optionals);
}
}
// build sets of includeds, optionals, and requireds
inclset = CustomUtils.noCaseNameSet(stripNames(m_includes));
if (optionals != null) {
optset = CustomUtils.noCaseNameSet(optionals);
}
if (requireds != null) {
reqset = CustomUtils.noCaseNameSet(requireds);
}
// classify names as elements or attributes
elemset = new HashSet();
attrset = new HashSet();
classifyNames(m_requireds, elemset, attrset);
classifyNames(m_optionals, elemset, attrset);
classifyNames(m_includes, elemset, attrset);
}
if (m_excludes != null) {
exclset = CustomUtils.noCaseNameSet(stripNames(m_excludes));
}
// first find members from property access methods
Map getmap = null;
Map setmap = null;
IClassItem[] methods = m_classInformation.getMethods();
GlobalCustom global = getGlobal();
if (global.isOutput()) {
// find properties using read access methods
getmap = mapPropertyReadMethods(methods, inclset, exclset);
if (global.isInput()) {
// find properties using write access methods
setmap = mapPropertyWriteMethods(methods, inclset, exclset);
// discard any read-only properties
for (Iterator iter = getmap.keySet().iterator(); iter.hasNext();) {
if (!setmap.containsKey(iter.next())) {
iter.remove();
}
}
}
}
if (global.isInput()) {
// find properties using write access methods
setmap = mapPropertyWriteMethods(methods, inclset, exclset);
}
// find members from fields
IClassItem[] fields = m_classInformation.getFields();
Map fieldmap = mapFields(fields, getStripPrefixes(), getStripSuffixes(), inclset, exclset);
// get list of names selected for use by options
if (m_includes == null) {
if (isPropertyAccess()) {
if (global.isOutput()) {
nameset.addAll(getmap.keySet());
} else {
nameset.addAll(setmap.keySet());
}
} else {
for (Iterator iter = fieldmap.keySet().iterator(); iter.hasNext();) {
String name = (String)iter.next();
IClassItem field = (IClassItem)fieldmap.get(name);
int access = field.getAccessFlags();
if (!Modifier.isStatic(access) && !Modifier.isTransient(access)) {
nameset.add(name);
}
}
}
}
// process all members found in class
m_memberMap = new InsertionOrderedMap();
boolean auto = !getName().startsWith("java.") && !getName().startsWith("javax.");
List names = nameset.asList();
for (Iterator iter = names.iterator(); iter.hasNext();) {
// get basic member information
String name = (String)iter.next();
String lcname = name.toLowerCase();
ValueCustom cust = null;
IClassItem gmeth = (IClassItem)(getmap == null ? null : getmap.get(name));
IClassItem smeth = (IClassItem)(setmap == null ? null : setmap.get(name));
IClassItem field = (IClassItem)(fieldmap == null ? null : fieldmap.get(name));
// find the optional/required setting
Boolean isreq = null;
if (optset.contains(lcname)) {
isreq = Boolean.FALSE;
}
if (reqset.contains(lcname)) {
isreq = Boolean.TRUE;
}
// find the style setting
Integer style = null;
if (attrset.contains(lcname)) {
style = ATTRIBUTE_STYLE_INTEGER;
} else if (elemset.contains(lcname)) {
style = ELEMENT_STYLE_INTEGER;
}
// check for existing customization
if (namemap.containsKey(name)) {
// fill in data missing from existing member customization
cust = (ValueCustom)namemap.get(name);
} else if (auto) {
if (isPropertyAccess()) {
if (gmeth != null || smeth != null) {
// create value information from methods
cust = new ValueCustom(this, name);
}
} else if (field != null) {
// create value information from field
cust = new ValueCustom(this, name);
}
}
// add customization to map
if (cust != null) {
if (isPropertyAccess()) {
cust.fillDetails(null, gmeth, smeth, icl, isreq, style);
} else {
cust.fillDetails(field, null, null, icl, isreq, style);
}
m_memberMap.put(name, cust);
}
}
// check for any supplied customizations that haven't been matched
for (Iterator iter = namemap.keySet().iterator(); iter.hasNext();) {
String name = (String)iter.next();
String lcname = name.toLowerCase();
if (!m_memberMap.containsKey(name)) {
// find the optional/required setting
Boolean req = null;
if (optset != null && optset.contains(lcname)) {
req = Boolean.FALSE;
}
if (reqset != null && reqset.contains(lcname)) {
req = Boolean.TRUE;
}
// find the style setting
Integer style = null;
if (attrset.contains(lcname)) {
style = ATTRIBUTE_STYLE_INTEGER;
} else if (elemset.contains(lcname)) {
style = ELEMENT_STYLE_INTEGER;
}
// complete the customization and add to map
ValueCustom cust = (ValueCustom)namemap.get(name);
cust.fillDetails(m_classInformation, req, style);
m_memberMap.put(name, cust);
}
}
}
/**
* Get customization information for a member by name. This method may only be called after
* {@link #apply(IClassLocator)}.
*
* @param name
* @return customization, or null if none
*/
public ValueCustom getMember(String name) {
return (ValueCustom)m_memberMap.get(name);
}
/**
* Get actual class information. This method may only be called after {@link #apply(IClassLocator)}.
*
* @return class information
*/
public IClass getClassInformation() {
return m_classInformation;
}
/**
* Get collection of members in class.
*
* @return members
*/
public Collection getMembers() {
return m_memberMap.values();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/ValueCustom.java 0000644 0001750 0001750 00000035046 11311542056 025736 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom.classes;
import java.lang.reflect.Modifier;
import org.apache.bcel.generic.Type;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.Utility;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
import org.jibx.util.IClassLocator;
import org.jibx.util.StringArray;
/**
* Member field or property customization information.
*
* @author Dennis M. Sosnoski
*/
public class ValueCustom extends SharedValueBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "attribute", "element", "field", "get-method", "property-name", "set-method" },
SharedValueBase.s_allowedAttributes);
//
// Internal instance data
/** Private property flag. */
private boolean m_private;
//
// Values handled by binding
/** 'field' attribute value (null if none). */
private String m_fieldName;
/** 'get-method' attribute value (null if none). */
private String m_getName;
/** 'set-method' attribute value (null if none). */
private String m_setName;
/** 'property-name' attribute value (null if none). */
private String m_propertyName;
/**
* Constructor.
*
* @param parent
*/
protected ValueCustom(SharedNestingBase parent) {
super(parent);
}
/**
* Constructor with name known.
*
* @param parent
* @param name
*/
protected ValueCustom(SharedNestingBase parent, String name) {
super(parent, name);
}
/**
* Get the member name for a property from the read method name. This means stripping off the leading "get" or "is"
* prefix, then case-converting the result.
*
* @param name
* @return member name
* @see #convertMemberNameCase(String)
* @see #memberNameFromSetMethod(String)
* @see #memberNameFromField(String, String[], String[])
*/
public static String memberNameFromGetMethod(String name) {
if (name.startsWith("get")) {
name = name.substring(3);
} else if (name.startsWith("is")) {
name = name.substring(2);
}
return convertMemberNameCase(name);
}
/**
* Get the member name for a property from the write method name. This means stripping off the leading "set" prefix,
* then case-converting the result.
*
* @param name
* @return member name
* @see #convertMemberNameCase(String)
* @see #memberNameFromGetMethod(String)
* @see #memberNameFromField(String, String[], String[])
*/
public static String memberNameFromSetMethod(String name) {
if (name.startsWith("set")) {
name = name.substring(3);
}
return convertMemberNameCase(name);
}
/**
* Get the member name for a field from the field name. This means stripping off and leading field name prefix
* and/or trailing suffix, then case-converting the result.
*
* @param name
* @param prefs field prefixes to be stripped
* @param suffs field suffixes to be stripped
* @return member name
* @see #convertMemberNameCase(String)
* @see #memberNameFromGetMethod(String)
* @see #memberNameFromSetMethod(String)
*/
public static String memberNameFromField(String name, String[] prefs, String[] suffs) {
if (prefs != null) {
for (int i = 0; i < prefs.length; i++) {
if (name.startsWith(prefs[i])) {
name = name.substring(prefs[i].length());
break;
}
}
}
if (suffs != null) {
for (int i = 0; i < suffs.length; i++) {
if (name.endsWith(prefs[i])) {
name = name.substring(name.length() - prefs[i].length());
break;
}
}
}
return convertMemberNameCase(name);
}
/**
* Set element name method. This is intended for use during unmarshalling, so it needs to allow for being called
* with a null value. TODO: add validation
*
* @param text (null if attribute not present)
* @param ictx
*/
private void setElement(String text, IUnmarshallingContext ictx) {
if (text != null) {
setXmlName(text);
setElementForced();
setStyle(new Integer(NestingBase.ELEMENT_VALUE_STYLE));
}
}
/**
* Set attribute name method. This is intended for use during unmarshalling, so it needs to allow for being called
* with a null value. TODO: add validation
*
* @param text (null if attribute not present)
* @param ictx
*/
private void setAttribute(String text, IUnmarshallingContext ictx) {
if (text != null) {
setXmlName(text);
setStyle(new Integer(NestingBase.ATTRIBUTE_VALUE_STYLE));
}
}
/**
* Check if member represents a property.
*
* @return true
*/
public boolean isProperty() {
return true;
}
/**
* Check if a private member.
*
* @return true if private, false if not
*/
public boolean isPrivate() {
return m_private;
}
/**
* Get 'field' attribute value.
*
* @return 'field' value (null if none)
*/
public String getFieldName() {
return m_fieldName;
}
/**
* Get 'get-method' attribute name.
*
* @return 'get' attribute name (null if none)
*/
public String getGetName() {
return m_getName;
}
/**
* Get 'set-method' attribute name.
*
* @return 'set-method' attribute name (null if none)
*/
public String getSetName() {
return m_setName;
}
/**
* Get 'property-name' attribute value.
*
* @return property name (null if none)
*/
public String getPropertyName() {
return m_propertyName;
}
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
*/
protected void preSet(IUnmarshallingContext uctx) {
validateAttributes(uctx, s_allowedAttributes);
}
/**
* Post-set method that handles checking attribute combinations and sets the actual member name.
*
* @throws JiBXException
*/
protected void postSet() throws JiBXException {
if (m_fieldName != null) {
if (m_getName != null || m_setName != null || m_propertyName != null) {
throw new JiBXException("'get-name' or 'set-name' or 'property-name' attributes cannot be used together with 'field' attribute on element");
}
ClassCustom clas = (ClassCustom)getParent();
setBaseName(memberNameFromField(m_fieldName, clas.getStripPrefixes(), clas.getStripSuffixes()));
} else if (m_getName == null && m_setName == null && m_propertyName == null) {
throw new JiBXException("Either 'field', 'get-name', 'set-name', or 'property-name' attribute is required on element");
} else {
if (m_setName == null) {
if (m_getName == null) {
setBaseName(m_propertyName);
} else {
setBaseName(memberNameFromGetMethod(m_getName));
}
} else {
setBaseName(memberNameFromSetMethod(m_setName));
}
}
}
/**
* Complete customization information based on either field or access method information.
*
* @param field (null if none)
* @param gmeth read access method (null if none)
* @param smeth write access method (null if none)
* @param icl class locator
* @param req required member flag (null if unknown)
* @param style representation style (null if unspecified)
*/
/* package */void fillDetails(IClassItem field, IClassItem gmeth, IClassItem smeth, IClassLocator icl, Boolean req,
Integer style) {
// fill in missing details for either field or property
String type = null;
if (field == null) {
if (gmeth != null) {
if (m_getName == null) {
m_getName = gmeth.getName();
}
type = gmeth.getTypeName();
}
if (smeth != null) {
if (m_setName == null) {
m_setName = smeth.getName();
}
if (type == null) {
type = smeth.getArgumentType(0);
}
}
m_private = (gmeth == null || Modifier.isPrivate(gmeth.getAccessFlags())) &&
(smeth == null || Modifier.isPrivate(smeth.getAccessFlags()));
} else {
if (m_fieldName == null) {
m_fieldName = field.getName();
}
m_private = Modifier.isPrivate(field.getAccessFlags());
type = field.getTypeName();
}
// fill in the details of type information
IClass info = icl.getClassInfo(type);
fillType(info, req, style);
if (isCollection()) {
if (getItemType() == null) {
String tname = getWorkingType();
if (tname.endsWith("[]")) {
// set item type directly from array type
setItemType(tname.substring(0, tname.length() - 2));
} else {
// find generic signature for type
String sig;
if (field != null) {
sig = field.getGenericsSignature();
} else {
if (gmeth == null) {
sig = smeth.getGenericsSignature();
} else {
sig = gmeth.getGenericsSignature();
}
}
// find type based on field or method signature
if (sig != null) {
int start = sig.indexOf('<');
int end = sig.lastIndexOf('>');
if (start > 0 && end > 0 && start < end) {
String tsig = sig.substring(start + 1, end);
if (tsig.indexOf('<') >= 0 || tsig.indexOf('+') >= 0) {
System.out.println("Warning: generic signature '" + tsig + "' ignored");
} else {
setItemType(Type.getType(tsig).toString());
}
}
}
}
}
if (getItemType() == null) {
setItemType("java.lang.Object");
}
// derive the item name if not already set
if (getItemName() == null) {
setItemName(deriveItemName(getXmlName(), getItemType(), getParent().getNameStyle()));
}
}
}
/**
* Complete customization information based on whatever field or access method information has been set.
*
* @param info containing class information
* @param req required member flag (null if unknown)
* @param style representation style (null if unspecified)
*/
/* package */void fillDetails(IClass info, Boolean req, Integer style) {
IClassItem field = null;
if (m_fieldName != null) {
field = info.getField(m_fieldName);
if (field == null) {
throw new IllegalArgumentException("Field " + m_fieldName + " not found in class " + info.getName());
}
}
IClassItem gmeth = null;
if (m_getName != null) {
gmeth = info.getBestMethod(m_getName, null, Utility.EMPTY_STRING_ARRAY);
if (gmeth == null) {
throw new IllegalArgumentException("get method " + m_getName + " not found in class " + info.getName());
}
}
IClassItem smeth = null;
if (m_setName != null) {
smeth = info.getBestMethod(m_setName, "void", null);
if (smeth == null) {
throw new IllegalArgumentException("gset method " + m_setName + " not found in class " + info.getName());
}
}
fillDetails(field, gmeth, smeth, info.getLocator(), req, style);
}
/**
* Factory method for creating instances during unmarshalling.
*
* @param ictx
* @return instance
*/
private static ValueCustom factory(IUnmarshallingContext ictx) {
return new ValueCustom(((ClassCustom)getContainingObject(ictx)));
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/ClassSourceLocator.java 0000644 0001750 0001750 00000014234 11167464036 027247 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom.classes;
import java.io.File;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.runtime.JiBXException;
import org.jibx.util.IClass;
import com.thoughtworks.qdox.JavaDocBuilder;
import com.thoughtworks.qdox.model.JavaClass;
/**
* Locator that supports both class file lookup and source file lookup.
*
* @author Dennis M. Sosnoski
*/
public class ClassSourceLocator implements IClassSourceLocator
{
/** Paths for source lookup. */
private final String[] m_sourcePaths;
/** Source file parser. */
private final JavaDocBuilder m_builder;
/** Set of classes parsed. */
private final Set m_lookupSet;
/**
* Constructor.
*
* @param paths source lookup paths (may be empty, but not null)
*/
public ClassSourceLocator(String[] paths) {
m_sourcePaths = paths;
m_builder = new JavaDocBuilder();
m_lookupSet = new HashSet();
}
/**
* Check if class lookup is supported. This always returns true.
*
* @return true
*/
public boolean isLookupSupported() {
return true;
}
/**
* Get the source code information for a class.
*
* @param name fully-qualified class name (using '$' as inner class marker)
* @return source code information, null if not available
*/
public JavaClass getSourceInfo(String name) {
int split = name.lastIndexOf('$');
if (split >= 0) {
JavaClass outer = getSourceInfo(name.substring(0, split));
if (outer == null) {
return null;
} else {
return outer.getNestedClassByName(name.substring(split + 1));
}
} else if (m_lookupSet.contains(name)) {
return m_builder.getClassByName(name);
} else {
for (int i = 0; i < m_sourcePaths.length; i++) {
StringBuffer buff = new StringBuffer();
buff.append(m_sourcePaths[i]);
int length = buff.length();
if (File.separatorChar != '/') {
for (int j = 0; j < length; j++) {
if (buff.charAt(j) == '/') {
buff.setCharAt(j, File.separatorChar);
}
}
}
if (length > 0 || buff.charAt(length - 1) != File.separatorChar) {
buff.append(File.separatorChar);
}
buff.append(name.replace('.', File.separatorChar));
buff.append(".java");
File file = new File(buff.toString());
if (file.exists()) {
try {
m_builder.addSource(file);
m_lookupSet.add(name);
return m_builder.getClassByName(name);
} catch (IOException e) {
throw new IllegalStateException("Unable to access source file " + buff.toString() + ": " +
e.getMessage());
}
}
}
return null;
}
}
/**
* Get the information for a class.
*
* @param name fully-qualified class name (using '$' as inner class marker)
* @return class information, or null if not found
*/
public IClass getClassInfo(String name) {
try {
ClassFile clas = ClassCache.getClassFile(name);
if (clas == null) {
return null;
} else {
return new ClassSourceWrapper(this, clas);
}
} catch (JiBXException e) {
throw new IllegalStateException("Error loading class " + name + ": " + e.getMessage());
}
}
/**
* Get required class information. If the class cannot be found a runtime
* exception is thrown.
*
* @param name fully-qualified name of class to be found
* @return class information
*/
public IClass getRequiredClassInfo(String name) {
IClass iclas = getClassInfo(name);
if (iclas == null) {
throw new IllegalStateException("Internal error: class " + name +
" cannot be found");
} else {
return iclas;
}
}
/**
* Load class.
*
* @param name fully-qualified class name
* @return loaded class, or null if not found
*/
public Class loadClass(String name) {
return ClassFile.loadClass(name);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/GlobalCustom.java 0000644 0001750 0001750 00000053410 11260415644 026062 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom.classes;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.jibx.binding.classes.ClassCache;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IUnmarshaller;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.util.IClass;
import org.jibx.util.IClassLocator;
import org.jibx.util.StringArray;
/**
* Global customization information. This includes some options specific to the <binding> element of the definition,
* as well as controls for structuring of the generated binding(s). It handles the binding customization child elements
* directly, by invoking the abstract unmarshallers for the child elements to process the content. It also allows for
* extension elements which are not part of the binding customization structure, as long as the binding in use defines
* the unmarshalling for these elements.
*
* @author Dennis M. Sosnoski
*/
public class GlobalCustom extends NestingBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "add-constructors", "direction", "force-classes", "track-source" },
NestingBase.s_allowedAttributes);
/** Element name in XML customization file. */
public static final String ELEMENT_NAME = "custom";
//
// Value set information
public static final int IN_BINDING = 0;
public static final int OUT_BINDING = 1;
public static final int BOTH_BINDING = 2;
/* package */static final EnumSet s_directionEnum =
new EnumSet(IN_BINDING, new String[] { "input", "output", "both" });
//
// Instance data
// structure for package hierarchy
private Map m_packageMap;
// class locator
private final IClassLocator m_classLocator;
// extension elements
private List m_extensionChildren;
// values applied directly to element (or to structure)
private boolean m_addConstructors;
private boolean m_forceClasses;
private boolean m_trackSource;
private boolean m_namespaceModular;
private boolean m_isInput;
private boolean m_isOutput;
private ArrayList m_unmarshalledClasses;
/**
* Constructor with class locator supplied.
*
* @param loc
*/
public GlobalCustom(IClassLocator loc) {
super(null);
m_packageMap = new HashMap();
m_classLocator = loc;
PackageCustom dflt = new PackageCustom("", "", this);
m_packageMap.put("", dflt);
m_isInput = true;
m_isOutput = true;
m_unmarshalledClasses = new ArrayList();
}
/**
* Constructor. This always creates the default package as the only direct child, since other packages will be
* treated as children of the default package.
*/
public GlobalCustom() {
this(new ClassCache.ClassCacheLocator());
}
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
*/
private void preSet(IUnmarshallingContext uctx) {
validateAttributes(uctx, s_allowedAttributes);
}
/**
* Get global customizations root.
*
* @return global customization
*/
public GlobalCustom getGlobal() {
return this;
}
/**
* Get list of unmarshalled classes. This list is populated by the custom unmarshalling code as the customizations
* document is unmarshalled.
*
* @return list
*/
public ArrayList getUnmarshalledClasses() {
return m_unmarshalledClasses;
}
//
// Access methods for values applied only at top level
/**
* Get 'add-constructors' setting.
*
* @return 'add-constructors' value
*/
public boolean isAddConstructors() {
return m_addConstructors;
}
/**
* Set 'add-constructors' value.
*
* @param add 'add-constructors' value
*/
public void setAddConstructors(boolean add) {
m_addConstructors = add;
}
/**
* Get 'force-classes' setting.
*
* @return 'force-classes' value
*/
public boolean isForceClasses() {
return m_forceClasses;
}
/**
* Set 'force-classes' value.
*
* @param force 'force-classes' value
*/
public void setForceClasses(boolean force) {
m_forceClasses = force;
}
/**
* Get 'track-source' attribute value.
*
* @return 'track-source' value
*/
public boolean isTrackSource() {
return m_trackSource;
}
/**
* Set 'track-source' value.
*
* @param track 'track-source' value
*/
public void setTrackSource(boolean track) {
m_trackSource = track;
}
/**
* Check for an input binding.
*
* @return input flag
*/
public boolean isInput() {
return m_isInput;
}
/**
* Set input binding flag.
*
* @param input
*/
public void setInput(boolean input) {
m_isInput = input;
}
/**
* Check for an output binding.
*
* @return output flag
*/
public boolean isOutput() {
return m_isOutput;
}
/**
* Set output binding falg.
*
* @param output
*/
public void setOutput(boolean output) {
m_isOutput = output;
}
/**
* Get class locator.
*
* @return locator
*/
protected IClassLocator getClassLocator() {
return m_classLocator;
}
/**
* Get class information.
*
* @param type fully-qualified class name
* @return information, or null if unable to load
*/
public IClass getClassInfo(String type) {
return m_classLocator.getClassInfo(type);
}
/**
* Get the extension elements used in this customization. This does not include the <package> or <class> child
* elements, which are added directly to the customization structures.
*
* @return child list
*/
public List getExtensionChildren() {
if (m_extensionChildren == null) {
return Collections.EMPTY_LIST;
} else {
return m_extensionChildren;
}
}
/**
* Internal method used during unmarshalling to add a child extension element.
*
* @param child
*/
protected void internalAddExtensionChild(Object child) {
if (m_extensionChildren == null) {
m_extensionChildren = new ArrayList();
}
m_extensionChildren.add(child);
}
/**
* Add a child extension element. This both adds the child to the list and invokes the extension element's
* {@link IApply#apply(IClassLocator)} method, if present.
*
* @param child
*/
public void addExtensionChild(Object child) {
internalAddExtensionChild(child);
if (child instanceof IApply) {
((IApply)child).apply(m_classLocator);
}
}
/**
* Check if a class is included in the customization information. This method does not alter the structures in any
* way, it only checks if the class customization information is part of the existing structure.
*
* @param type fully qualified class name
* @return true if class includes, false if not
*/
public boolean isClassUsed(String type) {
int split = type.lastIndexOf('.');
PackageCustom pack = (PackageCustom)m_packageMap.get(split < 0 ? "" : type.substring(0, split));
if (pack == null) {
return false;
} else {
return pack.getClassCustomization(type.substring(split + 1)) != null;
}
}
/**
* Get class customization information.
*
* @param type fully qualified class name
* @return class information (null if not defined)
*/
public ClassCustom getClassCustomization(String type) {
int split = type.lastIndexOf('.');
PackageCustom pack = (PackageCustom)m_packageMap.get(split < 0 ? "" : type.substring(0, split));
if (pack == null) {
return null;
} else {
return pack.getClassCustomization(type.substring(split + 1));
}
}
/**
* Build new class customization information. This creates the customization information and adds it to the internal
* structures, initializing all values based on the settings inherited from <package> and <global> elements of
* the structure. This method should only be used after first calling {@link #getClassCustomization(String)} and
* obtaining a null result.
*
* @param type fully qualified class name
* @return class information
*/
private ClassCustom buildClassCustomization(String type) {
int split = type.lastIndexOf('.');
PackageCustom pack = split < 0 ? getPackage("") : getPackage(type.substring(0, split));
ClassCustom clas = pack.addClassCustomization(type.substring(split + 1));
return clas;
}
/**
* Get class customization information, creating it if it doesn't already exist. This internal method supplies the
* class information in uninitialized form, so that data can be unmarshalled before initialization.
*
* @param type fully qualified class name
* @return class information
*/
private ClassCustom forceClassCustomization(String type) {
ClassCustom custom = getClassCustomization(type);
if (custom == null) {
custom = buildClassCustomization(type);
}
return custom;
}
/**
* Get initialized class customization information, creating it if it doesn't already exist.
*
* @param type fully qualified class name
* @return class information
*/
public ClassCustom addClassCustomization(String type) {
ClassCustom custom = getClassCustomization(type);
if (custom == null) {
custom = buildClassCustomization(type);
((PackageCustom)custom.getParent()).fixNamespace();
custom.apply(m_classLocator);
}
return custom;
}
/**
* Check if type represents a known mapping.
*
* @param type fully qualified class name
* @return known mapping flag
*/
public boolean isKnownMapping(String type) {
// TODO: add known mappings for org.w3c.dom.*, etc.
return false;
}
/**
* Direction set text method. This is intended for use during unmarshalling. TODO: add validation
*
* @param text
* @param ictx
*/
private void setDirectionText(String text, IUnmarshallingContext ictx) {
int direct = s_directionEnum.getValue(text);
if (direct < 0) {
throw new IllegalArgumentException("Value '" + text + "' not recognized for 'direction' attribute");
} else {
m_isInput = direct != OUT_BINDING;
m_isOutput = direct != IN_BINDING;
}
}
/**
* Direction get text method. This is intended for use during marshalling.
*
* @return text
*/
private String getDirectionText() {
if (m_isInput && m_isOutput) {
return s_directionEnum.getName(BOTH_BINDING);
} else if (m_isInput) {
return s_directionEnum.getName(IN_BINDING);
} else {
return s_directionEnum.getName(OUT_BINDING);
}
}
/**
* Initialize the global default namespace, along with special classes with built-in defaults. This needs to be done
* as a separate step before unmarshalling, so that the special classes are available for use.
*/
public void initClasses() {
// set default namespace
if (getNamespace() == null) {
setNamespace(getSpecifiedNamespace());
}
// create information for some special classes
ClassCustom custom = forceClassCustomization("java.util.List");
if (custom.getCreateType() == null && custom.getFactoryMethod() == null) {
custom.setCreateType("java.util.ArrayList");
}
custom = forceClassCustomization("java.util.Set");
if (custom.getCreateType() == null && custom.getFactoryMethod() == null) {
custom.setCreateType("java.util.HashSet");
}
custom = forceClassCustomization("java.util.Collection");
if (custom.getCreateType() == null && custom.getFactoryMethod() == null) {
custom.setCreateType("java.util.ArrayList");
}
}
/**
* Fills in class information based on inspection of the actual class data. This needs to be done as a separate step
* following unmarshalling, so that the full details of the unmarshalled customizations are available.
*/
public void fillClasses() {
// fill in details for all packages
for (Iterator iter = m_packageMap.values().iterator(); iter.hasNext();) {
PackageCustom pack = (PackageCustom)iter.next();
pack.fixNamespace();
pack.apply(m_classLocator);
}
// fill in details for any extension elements
if (m_extensionChildren != null) {
for (int i = 0; i < m_extensionChildren.size(); i++) {
Object child = m_extensionChildren.get(i);
if (child instanceof IApply) {
((IApply)child).apply(m_classLocator);
}
}
}
}
//
// Package structure support
/**
* Get package customizations. If the requested package is already defined the existing instance will be returned,
* otherwise a new instance will be created (along with any ancestor packages) and added to the structure.
*
* @param name
* @return package
*/
public PackageCustom getPackage(String name) {
// find existing package information
PackageCustom pack = (PackageCustom)m_packageMap.get(name);
if (pack == null) {
// create new package information
PackageCustom parent = null;
int split = name.lastIndexOf('.');
String simple = name;
String full = name;
if (split > 0) {
parent = getPackage(name.substring(0, split));
simple = name.substring(split + 1);
full = parent.getName() + '.' + simple;
} else if (name.length() > 0) {
parent = getPackage("");
}
pack = new PackageCustom(simple, full, parent);
m_packageMap.put(name, pack);
}
return pack;
}
/**
* Unmarshaller implementation for class. This handles the nested structure of packages and classes, using the
* abstract mappings defined by the binding to handle all the actual details.
*/
public static class Mapper implements IUnmarshaller
{
public boolean isPresent(IUnmarshallingContext ictx) throws JiBXException {
return true;
}
/**
* Build the fully-qualified name for a package or class by appending the supplied name attribute value to the
* fully-qualified name of the containing package.
*
* @param contain
* @param ctx
* @throws JiBXException
*/
private String buildFullName(PackageCustom contain, UnmarshallingContext ctx) throws JiBXException {
String lead = "";
if (contain != null) {
lead = contain.getName() + '.';
}
return lead + ctx.attributeText(null, "name");
}
/**
* Unmarshal package element. This calls itself recursively to handle nested package elements, and
* calls {@link #unmarshalClass(GlobalCustom, PackageCustom, UnmarshallingContext)} to handle nested
* class elements.
*
* @param global root customizations
* @param contain containing package
* @param ctx unmarshalling context
* @return unmarshalled package data
* @throws JiBXException
*/
private PackageCustom unmarshalPackage(GlobalCustom global, PackageCustom contain, UnmarshallingContext ctx)
throws JiBXException {
// create class instance and populate mapped values
PackageCustom inst = global.getPackage(buildFullName(contain, ctx));
ctx.getUnmarshaller("package").unmarshal(inst, ctx);
inst.fixNamespace();
// handle nested package and class information
while (ctx.isStart()) {
String element = ctx.getName();
if (PackageCustom.ELEMENT_NAME.equals(element)) {
unmarshalPackage(global, inst, ctx);
} else if (ClassCustom.ELEMENT_NAME.equals(element)) {
unmarshalClass(global, inst, ctx);
}
}
ctx.parsePastEndTag(null, PackageCustom.ELEMENT_NAME);
return inst;
}
/**
* Unmarshal class element. This calls itself recursively to handle nested class elements, and
* calls {@link #unmarshalClass(GlobalCustom, PackageCustom, UnmarshallingContext)} to handle nested
* class elements.
*
* @param global root customizations
* @param contain containing package
* @param ctx unmarshalling context
* @return unmarshalled class data
* @throws JiBXException
*/
private ClassCustom unmarshalClass(GlobalCustom global, PackageCustom contain, UnmarshallingContext ctx)
throws JiBXException {
// create class instance and populate mapped values
String name = buildFullName(contain, ctx);
int split = name.lastIndexOf('.');
PackageCustom pack = global.getPackage(split < 0 ? "" : name.substring(0, split));
pack.fixNamespace();
String simple = name.substring(split + 1);
ClassCustom inst = pack.getClassCustomization(simple);
if (inst == null) {
inst = pack.addClassCustomization(simple);
}
ctx.getUnmarshaller("class").unmarshal(inst, ctx);
ctx.parsePastEndTag(null, ClassCustom.ELEMENT_NAME);
// add to list unmarshalled
global.getUnmarshalledClasses().add(inst);
return inst;
}
/**
* Unmarshal root element of customizations. This expects to handle the actual root element of the binding
* directly, meaning it should always be invoked by using the
* {@link org.jibx.runtime.IUnmarshallable#unmarshal(IUnmarshallingContext)} method. The actual root element may
* be anything, allowing the unmarshaller to be used for subclasses (with different names) of the outer class.
*
* @param obj root element object (must be an instance of the GlobalCustom type)
* @param ictx unmarshalling context
* @return unmarshalled root object element
* @throws JiBXException
*/
public Object unmarshal(Object obj, IUnmarshallingContext ictx) throws JiBXException {
// initialize namespace and special classes
GlobalCustom global = (GlobalCustom)obj;
global.initClasses();
// unmarshal the wrapper element directly
UnmarshallingContext ctx = (UnmarshallingContext)ictx;
while (ctx.isStart()) {
// check type of child present
String element = ctx.getName();
if (PackageCustom.ELEMENT_NAME.equals(element)) {
unmarshalPackage(global, null, ctx);
} else if (ClassCustom.ELEMENT_NAME.equals(element)) {
unmarshalClass(global, null, ctx);
} else {
global.internalAddExtensionChild(ctx.unmarshalElement());
}
}
return global;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/ClassSourceWrapper.java 0000644 0001750 0001750 00000006045 11062041236 027250 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom.classes;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.ClassItem;
import org.jibx.binding.model.ClassWrapper;
import org.jibx.util.IClassItem;
import com.thoughtworks.qdox.model.JavaClass;
/**
* Wrapper for class with added source information. This wraps the basic class handling implementation with added
* support for retrieving information from source files.
*
* @author Dennis M. Sosnoski
*/
public class ClassSourceWrapper extends ClassWrapper
{
/**
* Constructor.
*
* @param loc
* @param clas
*/
public ClassSourceWrapper(IClassSourceLocator loc, ClassFile clas) {
super(loc, clas);
}
/**
* Build an item wrapper. This override of the base class implementation always creates a wrapper which will support
* source operations.
*
* @param item
* @return wrapper
*/
protected IClassItem buildItem(ClassItem item) {
return new ClassItemSourceWrapper(this, item);
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.model.IClass#getJavaDoc()
*/
public String getJavaDoc() {
IClassSourceLocator loc = (IClassSourceLocator)getLocator();
JavaClass jc = loc.getSourceInfo(getClassFile().getName());
if (jc != null) {
String text = jc.getComment();
if (text != null) {
text = text.trim();
if (text.length() > 0) {
return text;
}
}
}
return null;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/IClassSourceLocator.java 0000644 0001750 0001750 00000004143 11062041246 027342 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom.classes;
import org.jibx.util.IClassLocator;
import com.thoughtworks.qdox.model.JavaClass;
/**
* Locator for class and/or source information. Looks up class and source data as requested, using whatever method is
* appropriate for the usage environment.
*
* @author Dennis M. Sosnoski
*/
public interface IClassSourceLocator extends IClassLocator
{
/**
* Get source information.
*
* @param name fully-qualified name of class to be found
* @return source information, or null if source not found
*/
public JavaClass getSourceInfo(String name);
}
libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/IDocumentFormatter.java 0000644 0001750 0001750 00000005515 11124146174 027243 0 ustar twerner twerner /*
* Copyright (c) 2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom.classes;
import java.util.List;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
/**
* Formatter interface for JavaDoc conversion to XML documentation components.
*/
public interface IDocumentFormatter
{
/** Default implementation class for interface. */
static final String DEFAULT_IMPLEMENTATION = "org.jibx.schema.generator.DocumentFormatter";
/**
* Convert JavaDoc text to a list of formatted nodes.
*
* @param jdoc JavaDoc text (may be null)
* @return formatted representation (may be null)
*/
List docToNodes(String jdoc);
/**
* Get formatted documentation from class. Implementations must return the documentation components in the form of
* a list of org.w3c.dom.Node instances.
*
* @param info class information
* @return formatted documentation (null if none)
*/
List getClassDocumentation(IClass info);
/**
* Get formatted documentation from class item. Implementations must return the documentation components in the form
* of a list of org.w3c.dom.Node instances.
*
* @param info class item information
* @return formatted representation (null if none)
*/
List getItemDocumentation(IClassItem info);
} libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/CustomBase.java 0000644 0001750 0001750 00000033540 11062041246 025527 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom.classes;
import java.util.Collection;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.NameUtilities;
import org.jibx.util.StringArray;
/**
* Base class for all customizations. This defines a way to navigate up the tree of nested components without making
* assumptions about the specific type of the containing components. This allows for other types of customizations,
* beyond the binding customizations included directly in this package. This also includes enumeration definitions which
* are used with both base and extension customizations.
*
* @author Dennis M. Sosnoski
*/
public class CustomBase
{
// name style value set information
public static final int CAMEL_CASE_NAMES = 0;
public static final int UPPER_CAMEL_CASE_NAMES = 1;
public static final int HYPHENATED_NAMES = 2;
public static final int DOTTED_NAMES = 3;
public static final int UNDERSCORED_NAMES = 4;
public static final EnumSet s_nameStyleEnum =
new EnumSet(CAMEL_CASE_NAMES, new String[] { "camel-case", "upper-camel-case", "hyphenated", "dotted",
"underscored" });
// require value set information
public static final int REQUIRE_NONE = 0;
public static final int REQUIRE_PRIMITIVES = 1;
public static final int REQUIRE_OBJECTS = 2;
public static final int REQUIRE_ALL = 3;
public static final EnumSet s_requireEnum =
new EnumSet(REQUIRE_NONE, new String[] { "none", "primitives", "objects", "all" });
// derive-namespace value set information
public static final int DERIVE_NONE = 0;
public static final int DERIVE_BY_PACKAGE = 1;
public static final int DERIVE_FIXED = 2;
public static final EnumSet s_namespaceStyleEnum =
new EnumSet(DERIVE_NONE, new String[] { "none", "package", "fixed" });
// parent element (null if none) - would be final, except for unmarshalling
private SharedNestingBase m_parent;
/**
* Constructor.
*
* @param parent
*/
public CustomBase(SharedNestingBase parent) {
m_parent = parent;
}
/**
* Get container.
*
* @return container
*/
public SharedNestingBase getParent() {
return m_parent;
}
/**
* Get global customizations root.
*
* @return global customization
*/
public GlobalCustom getGlobal() {
CustomBase parent = m_parent;
while (!(parent instanceof GlobalCustom)) {
parent = parent.getParent();
}
return (GlobalCustom)parent;
}
/**
* Convert class, method, or parameter name to XML name.
*
* @param base class or simple field name to be converted
* @param code conversion format style code
* @return XML name
*/
public static String convertName(String base, int code) {
// strip off trailing array indication
while (base.endsWith("[]")) {
base = base.substring(0, base.length() - 2);
}
// skip any leading special characters in name
int length = base.length();
int offset = -1;
char chr = 0;
while (++offset < length && ((chr = base.charAt(offset)) == '_' || (chr == '$')));
if (offset >= length) {
return "_";
} else {
// make sure valid first character of name
StringBuffer buff = new StringBuffer();
if (Character.isDigit(chr)) {
buff.append('_');
}
// scan for word splits in supplied name
boolean split = true;
boolean caps = false;
while (offset < length) {
// split if underscore or change to upper case, or upper ending
chr = base.charAt(offset++);
boolean nextlower = offset < length && !Character.isUpperCase(base.charAt(offset));
if (chr == '_') {
split = true;
continue;
} else if (Character.isUpperCase(chr)) {
if (!caps || nextlower) {
split = true;
}
if (code != CAMEL_CASE_NAMES && code != UPPER_CAMEL_CASE_NAMES) {
chr = Character.toLowerCase(chr);
}
}
if (split) {
// convert word break
caps = !nextlower;
boolean tolower = false;
char separator = 0;
switch (code) {
case CAMEL_CASE_NAMES: {
if (buff.length() != 0) {
chr = Character.toUpperCase(chr);
tolower = false;
} else {
tolower = nextlower || offset == length;
}
break;
}
case UPPER_CAMEL_CASE_NAMES: {
tolower = false;
chr = Character.toUpperCase(chr);
break;
}
case HYPHENATED_NAMES: {
separator = '-';
break;
}
case DOTTED_NAMES: {
separator = '.';
break;
}
case UNDERSCORED_NAMES: {
separator = '_';
break;
}
}
if (separator > 0 && buff.length() > 0) {
buff.append(separator);
}
if (tolower) {
chr = Character.toLowerCase(chr);
}
split = false;
}
if (chr != '$') {
// no split, just append the character
buff.append(chr);
}
}
return buff.toString();
}
}
/**
* Derive name for item in a collection. If the supplied collection name ends in a recognized plural form the
* derived item name is the singular version of the collection name. Otherwise, it is the converted name of the
* collection item class, or just "item" if the class is unknown. TODO: internationalization?
*
* @param cname collection name (null if none)
* @param type item type (null if unknown)
* @param code conversion format style code
* @return item name
*/
public static String deriveItemName(String cname, String type, int code) {
if (cname != null) {
String name = NameUtilities.depluralize(cname);
if (!name.equals(cname)) {
return name;
}
}
if (type != null && !"java.lang.Object".equals(type)) {
return convertName(type.substring(type.lastIndexOf('.') + 1), code);
} else {
return "item";
}
}
/**
* Get the package from a fully-qualified type name.
*
* @param type fully-qualified type name
* @return package of the type (empty string if in default package)
*/
public static String packageOfType(String type) {
int split = type.lastIndexOf('.');
if (split >= 0) {
return type.substring(0, split);
} else {
return "";
}
}
/**
* Create a namespace URL from a package path.
*
* @param pkgpth fully-qualified package name
* @return namespace based on package (null if none)
*/
public static String packageToNamespace(String pkgpth) {
int mark = pkgpth.indexOf('.');
if (mark >= 0) {
StringBuffer buff = new StringBuffer();
buff.append("http://");
String comp = pkgpth.substring(0, mark);
int base = mark + 1;
char delim = '.';
if ("com".equals(comp) || "net".equals(comp) || "org".equals(comp)) {
mark = pkgpth.indexOf('.', base);
if (mark > 0) {
buff.append(pkgpth.substring(base, mark));
} else {
buff.append(pkgpth.substring(base));
}
buff.append('.');
base = mark + 1;
delim = '/';
}
buff.append(comp);
while (mark > 0) {
buff.append(delim);
base = mark + 1;
mark = pkgpth.indexOf('.', base);
if (mark > 0) {
buff.append(pkgpth.substring(base, mark));
} else {
buff.append(pkgpth.substring(base));
}
}
return buff.toString();
} else {
return null;
}
}
/**
* Derive namespace using specified technique.
*
* @param uri base namespace URI (null if none)
* @param pkgpth fully qualified package name
* @param style namespace style code
* @return derived namespace
*/
public static String deriveNamespace(String uri, String pkgpth, int style) {
switch (style) {
case DERIVE_NONE:
return null;
case DERIVE_FIXED:
return uri;
case DERIVE_BY_PACKAGE: {
if (uri == null) {
return packageToNamespace(pkgpth);
} else if (pkgpth == null) {
return uri;
} else {
// append the last package to passed URI
String pack;
int start = pkgpth.lastIndexOf('.');
if (start >= 0) {
pack = pkgpth.substring(start + 1);
} else {
pack = pkgpth;
}
if (uri.endsWith("/")) {
return uri + pack;
} else {
return uri + '/' + pack;
}
}
}
default:
throw new IllegalStateException("Invalid style code");
}
}
/**
* Validate attributes of element. This is designed to be called during unmarshalling as part of the pre-set method
* processing when a subclass instance is being created.
*
* @param ictx unmarshalling context
* @param attrs attributes array
*/
protected void validateAttributes(IUnmarshallingContext ictx, StringArray attrs) {
// setup for attribute access
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
UnmarshallingContext uctx = (UnmarshallingContext)ictx;
// loop through all attributes of current element
for (int i = 0; i < uctx.getAttributeCount(); i++) {
// check if nonamespace attribute is in the allowed set
String name = uctx.getAttributeName(i);
if (uctx.getAttributeNamespace(i).length() == 0) {
if (attrs.indexOf(name) < 0) {
vctx.addWarning("Undefined attribute " + name, this);
}
}
}
}
/**
* Gets the parent element link from the unmarshalling stack. This method is for use by factories during
* unmarshalling.
*
* @param ictx unmarshalling context
* @return containing class
*/
protected static Object getContainingObject(IUnmarshallingContext ictx) {
Object parent = ictx.getStackTop();
if (parent instanceof Collection) {
parent = ictx.getStackObject(1);
}
return parent;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/custom/classes/ClassCustomizationBase.java 0000644 0001750 0001750 00000016730 11323706030 030114 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.custom.classes;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.jibx.binding.Utility;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.custom.CustomizationCommandLineBase;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.schema.validation.ValidationProblem;
import org.jibx.util.IClassLocator;
/**
* Command line processor for customizable tools working with Java classes.
*
* @author Dennis M. Sosnoski
*/
public abstract class ClassCustomizationBase extends CustomizationCommandLineBase
{
/** Ordered array of usage lines. */
private static final String[] BASE_USAGE_LINES =
new String[] { " -p path,... class loading paths",
" -s path,... source paths" };
/** List of class paths. */
private List m_classPaths;
/** List of source paths. */
private List m_sourcePaths;
/**
* Constructor.
*
* @param lines
*/
protected ClassCustomizationBase(String[] lines) {
super(mergeUsageLines(lines, BASE_USAGE_LINES));
m_classPaths = new ArrayList();
m_sourcePaths = new ArrayList();
}
/**
* Split items from a comma-delimited list.
*
* @param text comma-delimited list
* @param values target list of item values
*/
protected static void splitItems(String text, List values) {
int base = 0;
int split;
while ((split = text.indexOf(',', base)) >= 0) {
values.add(text.substring(base, split));
base = split + 1;
}
values.add(text.substring(base));
}
/**
* Check if an extension parameter is recognized. Subclasses which override this method should call the base class
* method before doing their own checks, and only perform their own checks if this method returns
* false..
*
* @param alist argument list
* @return true if parameter processed, false if unknown
*/
protected boolean checkParameter(ArgList alist) {
boolean match = true;
String arg = alist.current();
if ("-p".equalsIgnoreCase(arg)) {
splitItems(alist.next(), m_classPaths);
} else if ("-s".equalsIgnoreCase(arg)) {
splitItems(alist.next(), m_sourcePaths);
} else {
match = super.checkParameter(alist);
}
return match;
}
/**
* Finish processing of command line parameters. This adds the JVM classpath directories to the set of paths
* specified on the command line. Subclasses which override this method need to call this base class implementation
* as part of their processing.
*
* @param alist
*/
protected void finishParameters(ArgList alist) {
// add JVM class path directories to those specified on command line
String[] vmpaths = Utility.getClassPaths();
for (int i = 0; i < vmpaths.length; i++) {
m_classPaths.add(vmpaths[i]);
}
// set paths to be used for loading referenced classes
String[] parray = (String[])m_classPaths.toArray(new String[m_classPaths.size()]);
ClassCache.setPaths(parray);
ClassFile.setPaths(parray);
}
/**
* Print any extension details. This method may be overridden by subclasses to print extension parameter values for
* verbose output, but the base class implementation should be called first.
*/
protected void verboseDetails() {
System.out.println("Using class loading paths:");
for (int i = 0; i < m_classPaths.size(); i++) {
System.out.println(" " + m_classPaths.get(i));
}
System.out.println("Using source loading paths:");
for (int i = 0; i < m_sourcePaths.size(); i++) {
System.out.println(" " + m_sourcePaths.get(i));
}
System.out.println("Starting from classes:");
List types = getExtraArgs();
for (int i = 0; i < types.size(); i++) {
System.out.println(" " + types.get(i));
}
}
/**
* Load the customizations file. This method must load the specified customizations file, or create a default
* customizations instance, of the appropriate type.
*
* @param path customization file path
* @return true if successful, false if an error
* @throws JiBXException
* @throws IOException
*/
protected boolean loadCustomizations(String path) throws JiBXException, IOException {
// load customizations and check for errors
String[] spaths = (String[])m_sourcePaths.toArray(new String[m_sourcePaths.size()]);
ValidationContext vctx = new ValidationContext();
loadCustomizations(path, new ClassSourceLocator(spaths), vctx);
ArrayList probs = vctx.getProblems();
if (probs.size() > 0) {
for (int i = 0; i < probs.size(); i++) {
ValidationProblem prob = (ValidationProblem)probs.get(i);
System.out.print(prob.getSeverity() >=
ValidationProblem.ERROR_LEVEL ? "Error: " : "Warning: ");
System.out.println(prob.getDescription());
}
if (vctx.getErrorCount() > 0 || vctx.getFatalCount() > 0) {
return false;
}
}
return true;
}
/**
* Load the customizations file. This method must load the specified customizations file, or create a default
* customizations instance, of the appropriate type.
*
* @param path customizations file path, null if none
* @param loc class locator
* @param vctx validation context
* @throws JiBXException
* @throws IOException
*/
protected abstract void loadCustomizations(String path, IClassLocator loc, ValidationContext vctx)
throws JiBXException, IOException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/ 0000755 0001750 0001750 00000000000 11472231716 020304 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/ 0000755 0001750 0001750 00000000000 11300355306 021245 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/model/ 0000755 0001750 0001750 00000000000 11526304014 022345 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/model/Message.java 0000644 0001750 0001750 00000005465 11325066070 024612 0 ustar twerner twerner /*
* Copyright (c) 2004-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.model;
import java.util.List;
import org.jibx.runtime.QName;
import org.jibx.util.LazyList;
/**
* WSDL object model components corresponding to a message definition.
*
* @author Dennis M. Sosnoski
*/
public class Message
{
/** Actual message name. */
private String m_name;
/** Qualified name in WSDL target namespace. */
private QName m_qName;
/** Parts defined for this message. */
private List m_parts;
/**
* Constructor from message name and singleton part.
*
* @param name message name
* @param tns target namespace
*/
public Message(String name, String tns) {
m_name = name;
m_qName = new QName(tns, name);
m_parts = new LazyList();
}
/**
* Get message name.
*
* @return message name
*/
public String getName() {
return m_name;
}
/**
* Get qualified name.
*
* @return qualified name
*/
public QName getQName() {
return m_qName;
}
/**
* Set qualified name.
*
* @param name
*/
public void setQName(QName name) {
m_qName = name;
}
/**
* Get message parts.
*
* @return list of parts
*/
public List getParts() {
return m_parts;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/model/MessageReference.java 0000644 0001750 0001750 00000011503 11124146322 026413 0 ustar twerner twerner /*
* Copyright (c) 2004-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.model;
/**
* Reference to a message within an operation. Since messages may be referenced as input, output, or fault messages, the
* appropriate type is tracked by this class, along with the actual message.
*
* @author Dennis M. Sosnoski
*/
public class MessageReference
{
/** Reference to message as input. */
public static final int INPUT_REFERENCE = 0;
/** Reference to message as output. */
public static final int OUTPUT_REFERENCE = 1;
/** Reference to message as fault. */
public static final int FAULT_REFERENCE = 2;
/** Type of message reference. */
private int m_usage;
/** Name for this reference. */
private String m_name;
/** Actual message. */
private Message m_message;
/**
* Internal constructor used with JiBX binding.
*
* @param usage reference type code
*/
private MessageReference(int usage) {
m_usage = usage;
}
/**
* Constructor from part and element names.
*
* @param usage reference type code
* @param msg referenced message
*/
public MessageReference(int usage, Message msg) {
m_usage = usage;
m_message = msg;
}
/**
* Check if reference is to message as input.
*
* @return true if input reference, false if not
*/
public boolean isInput() {
return m_usage == INPUT_REFERENCE;
}
/**
* Check if reference is to message as output.
*
* @return true if output reference, false if not
*/
public boolean isOutput() {
return m_usage == OUTPUT_REFERENCE;
}
/**
* Check if reference is to message as fault.
*
* @return true if fault reference, false if not
*/
public boolean isFault() {
return m_usage == FAULT_REFERENCE;
}
/**
* Get name for this reference.
*
* @return reference name
*/
public String getName() {
return m_name;
}
/**
* Set name for this reference.
*
* @param name
*/
public void setName(String name) {
m_name = name;
}
/**
* Get referenced message.
*
* @return referenced message
*/
public Message getMessage() {
return m_message;
}
/**
* Factory for creating input message reference templates. The actual referenced message information needs to be set
* separately.
*
* @return created reference
*/
private static MessageReference inputReferenceFactory() {
return new MessageReference(INPUT_REFERENCE);
}
/**
* Factory for creating output message reference templates. The actual referenced message information needs to be
* set separately.
*
* @return created reference
*/
private static MessageReference outputReferenceFactory() {
return new MessageReference(OUTPUT_REFERENCE);
}
/**
* Factory for creating fault message reference templates. The actual referenced message information needs to be set
* separately.
*
* @return created reference
*/
private static MessageReference faultReferenceFactory() {
return new MessageReference(FAULT_REFERENCE);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/model/OpenAttrBase.java 0000644 0001750 0001750 00000014207 11160703074 025546 0 ustar twerner twerner /*
* Copyright (c) 2006-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.model;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.jibx.binding.model.EmptyArrayList;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.IXMLWriter;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.util.StringArray;
/**
* Base class for all element structures in WSDL definition which allow arbitrary attributes from outside the WSDL
* namespace.
*
* @author Dennis M. Sosnoski
*/
public abstract class OpenAttrBase extends WsdlBase
{
/** Extra attributes associated with element (lazy create, null if unused). */
private ArrayList m_attributes;
//
// Overrides of base class methods
/**
* Get the WSDL target namespace.
*
* @return namespace
*/
public String getNamespace() {
return "http://schemas.xmlsoap.org/wsdl/";
}
//
// Binding methods
/**
* Pre-get method called during marshalling. This first calls the base class implementation to handle namespaces,
* then writes any extra attributes to the element start tag.
*
* @param ictx marshalling context
* @throws JiBXException on error
*/
protected void preget(IMarshallingContext ictx) throws JiBXException {
// call base class implementation to handle namespaces
super.preget(ictx);
// write all extra attributes to element start tag
if (m_attributes != null) {
IXMLWriter writer = ictx.getXmlWriter();
for (int i = 0; i < m_attributes.size();) {
String name = (String)m_attributes.get(i++);
String uri = (String)m_attributes.get(i++);
String value = (String)m_attributes.get(i++);
int index = writer.getNamespaceCount();
while (--index >= 0 && !uri.equals(writer.getNamespaceUri(index)));
if (index >= 0) {
try {
writer.addAttribute(index, name, value);
} catch (IOException e) {
throw new JiBXException("Error writing attribute", e);
}
} else {
throw new JiBXException("Namespace uri \"" + uri + "\" is not defined");
}
}
}
}
//
// Access methods
/**
* Get read-only list of extra attributes. Entries in this list are triplets, consisting of attribute name,
* namespace, and value.
*
* @return extra attribute list
*/
public final List getExtraAttributes() {
if (m_attributes == null || m_attributes.size() == 0) {
return EmptyArrayList.INSTANCE;
} else {
return Collections.unmodifiableList(m_attributes);
}
}
/**
* Clear extra attribute list.
*/
public final void clearExtraAttributes() {
if (m_attributes != null) {
m_attributes.clear();
}
}
/**
* Add extra attribute.
*
* @param name attribute name
* @param uri attribute namespace URI
* @param value attribute value
*/
public final void addExtraAttribute(String name, String uri, String value) {
if (m_attributes == null) {
m_attributes = new ArrayList();
}
m_attributes.add(name);
m_attributes.add(uri);
m_attributes.add(value);
}
//
// Validation methods
/**
* Validate attributes of element from schema namespace. This allows any number of attributes from other namespaces
* on the element.
*
* @param ictx unmarshalling context
* @param attrs attributes array
* @exception JiBXException on unmarshalling error
*/
protected void validateAttributes(IUnmarshallingContext ictx, StringArray attrs) throws JiBXException {
// handle basic validation
readNamespaces(ictx);
validateAttributes(ictx, true, attrs);
// loop through all attributes of current element
UnmarshallingContext uctx = (UnmarshallingContext)ictx;
clearExtraAttributes();
for (int i = 0; i < uctx.getAttributeCount(); i++) {
// collect attributes from non-schema namespaces
String ns = uctx.getAttributeNamespace(i);
if (ns != null && ns.length() > 0 && !getNamespace().equals(ns)) {
addExtraAttribute(uctx.getAttributeName(i), ns, uctx.getAttributeValue(i));
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/model/Operation.java 0000644 0001750 0001750 00000010372 11124146322 025153 0 ustar twerner twerner /*
* Copyright (c) 2004-2007, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.model;
import java.util.ArrayList;
import java.util.List;
/**
* WSDL object model component corresponding to an operation definition.
*
* @author Dennis M. Sosnoski
*/
public class Operation
{
/** Actual operation name. */
private String m_name;
/** SOAP action. */
private String m_soapAction;
/** Documentation as node list (null if none). */
private List m_documentation;
/** Ordered message references for this operation. */
private ArrayList m_messageRefs;
/**
* Constructor from operation name.
*
* @param name operation name
*/
public Operation(String name) {
m_name = name;
m_soapAction = "";
m_messageRefs = new ArrayList();
}
/**
* Add reference to input message. All input message(s) must be set before any output or fault messages are set.
*
* @param msg input message
*/
public void addInputMessage(Message msg) {
m_messageRefs.add(new MessageReference(MessageReference.INPUT_REFERENCE, msg));
}
/**
* Add reference to output message. All output message(s) must be set after any input messages and before any fault
* messages are set.
*
* @param msg output message
*/
public void addOutputMessage(Message msg) {
m_messageRefs.add(new MessageReference(MessageReference.OUTPUT_REFERENCE, msg));
}
/**
* Add reference to fault message. All fault message(s) must be set after any input or output messages are set.
*
* @param msg fault message
*/
public void addFaultMessage(Message msg) {
m_messageRefs.add(new MessageReference(MessageReference.FAULT_REFERENCE, msg));
}
/**
* Get operation name.
*
* @return operation name
*/
public String getName() {
return m_name;
}
/**
* Get soapAction.
*
* @return soapAction
*/
public String getSoapAction() {
return m_soapAction;
}
/**
* Set soapAction.
*
* @param action
*/
public void setSoapAction(String action) {
m_soapAction = action;
}
/**
* Get documentation.
*
* @return list of nodes
*/
public List getDocumentation() {
return m_documentation;
}
/**
* Set documentation.
*
* @param nodes list of nodes
*/
public void setDocumentation(List nodes) {
m_documentation = nodes;
}
/**
* Get message references for operation. The returned list is live, but should not be modified by the caller.
*
* @return list of parts
*/
public ArrayList getMessageReferences() {
return m_messageRefs;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/model/Definitions.java 0000644 0001750 0001750 00000016203 11325701100 025457 0 ustar twerner twerner /*
* Copyright (c) 2004-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.model;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.jibx.runtime.QName;
/**
* Top-level component of WSDL definition.
* TODO: modify to support multiple portTypes, bindings, and services
*
* @author Dennis M. Sosnoski
*/
public class Definitions extends WsdlBase
{
/** Transport specification for SOAP over HTTP. */
public static final String HTTP_TRANSPORT = "http://schemas.xmlsoap.org/soap/http";
/** Supported style value. */
public static final String STYLE_DOCUMENT = "document";
/** Prefix for WSDL target namespace. */
private String m_wsdlPrefix;
/** Target namespace for WSDL. */
private String m_wsdlNamespace;
/** Name for port type. */
private String m_portTypeName;
/** Name for binding. */
private String m_bindingName;
/** Name for service. */
private String m_serviceName;
/** Name for port. */
private String m_portName;
/** Schema definition holders. */
private ArrayList m_schemas;
/** Message definitions. */
private ArrayList m_messages;
/** Operation definitions. */
private ArrayList m_operations;
/** Documentation for the portType. */
private List m_portTypeDocumentation;
/** Service location URL. */
private String m_serviceLocation;
/** Namespaces referenced from WSDL. */
private Set m_namespaceUris;
/**
* Default constructor. This is only used by the unmarshalling code.
*/
private Definitions() {}
/**
* Standard constructor.
*
* @param tname port type name
* @param bname binding name
* @param sname service name
* @param pname port name
* @param wpfx prefix for WSDL target namespace
* @param wuri WSDL target namespace
*/
public Definitions(String tname, String bname, String sname, String pname, String wpfx, String wuri) {
this();
m_portTypeName = tname;
m_bindingName = bname;
m_serviceName = sname;
m_portName = pname;
m_wsdlPrefix = wpfx;
m_wsdlNamespace = wuri;
m_schemas = new ArrayList();
m_messages = new ArrayList();
m_operations = new ArrayList();
m_namespaceUris = new HashSet();
m_namespaceUris.add(wuri);
addNamespaceDeclaration(wpfx, wuri);
}
/**
* Set service location.
*
* @param sloc service location URL string
*/
public void setServiceLocation(String sloc) {
m_serviceLocation = sloc;
}
/**
* Add message definition.
*
* @param msg message definition
*/
public void addMessage(Message msg) {
m_messages.add(msg);
}
/**
* Add operation definition.
*
* @param op operation definition
*/
public void addOperation(Operation op) {
m_operations.add(op);
}
/**
* Get port type name.
*
* @return port type name
*/
public String getPortTypeName() {
return m_portTypeName;
}
/**
* Get port type qualified name
*
* @return port type qualified name
*/
public QName getPortTypeQName() {
return new QName(m_wsdlNamespace, m_portTypeName);
}
/**
* Get binding name.
*
* @return binding name
*/
public String getBindingName() {
return m_bindingName;
}
/**
* Get binding qualified name
*
* @return binding qualified name
*/
public QName getBindingQName() {
return new QName(m_wsdlNamespace, m_bindingName);
}
/**
* Get service name.
*
* @return service name
*/
public String getServiceName() {
return m_serviceName;
}
/**
* Get port name.
*
* @return port name
*/
public String getPortName() {
return m_portTypeName;
}
/**
* Get WSDL target namespace prefix.
*
* @return target namespace prefix
*/
public String getWsdlPrefix() {
return m_wsdlPrefix;
}
/**
* Get WSDL target namespace URI.
*
* @return target namespace
*/
public String getWsdlNamespace() {
return m_wsdlNamespace;
}
/**
* Get schema definition holders.
*
* @return schemas
*/
public ArrayList getSchemas() {
return m_schemas;
}
/**
* Get service location.
*
* @return service location URL string
*/
public String getServiceLocation() {
return m_serviceLocation;
}
/**
* Get portType documentation.
*
* @return list of nodes
*/
public List getPortTypeDocumentation() {
return m_portTypeDocumentation;
}
/**
* Set portType documentation.
*
* @param nodes list of nodes
*/
public void setPortTypeDocumentation(List nodes) {
m_portTypeDocumentation = nodes;
}
/**
* Get messages.
*
* @return list of messages
*/
public ArrayList getMessages() {
return m_messages;
}
/**
* Get operations.
*
* @return list of operations
*/
public ArrayList getOperations() {
return m_operations;
}
/**
* Add namespace to set declared in WSDL. This just uses numbered prefixes.
*
* @param uri
*/
public void addNamespace(String uri) {
if (!m_namespaceUris.contains(uri)) {
addNamespaceDeclaration("ns"+m_namespaceUris.size(), uri);
m_namespaceUris.add(uri);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/model/MessagePart.java 0000644 0001750 0001750 00000005274 11124146322 025433 0 ustar twerner twerner /*
* Copyright (c) 2004-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.model;
import org.jibx.runtime.QName;
/**
* WSDL object model components corresponding to a message definition part.
*
* @author Dennis M. Sosnoski
*/
public class MessagePart
{
/** Actual part name. */
private String m_name;
/** Referenced element. */
private QName m_elementReference;
/**
* Constructor from part and element names.
*
* @param mname message name
* @param eref element qualified name
*/
public MessagePart(String mname, QName eref) {
m_name = mname;
m_elementReference = eref;
}
/**
* Get part name.
*
* @return part name
*/
public String getName() {
return m_name;
}
/**
* Set part name.
*
* @param name
*/
public void setName(String name) {
m_name = name;
}
/**
* Get referenced element name.
*
* @return element name
*/
public QName getElementReference() {
return m_elementReference;
}
/**
* Set referenced element name.
*
* @param ref
*/
public void setElementReference(QName ref) {
m_elementReference = ref;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/model/WsdlBase.java 0000644 0001750 0001750 00000032442 11160703212 024716 0 ustar twerner twerner /*
* Copyright (c) 2006-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.model;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.jibx.binding.model.EmptyArrayList;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.IXMLWriter;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.GrowableIntArray;
import org.jibx.runtime.impl.GrowableStringArray;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
import org.jibx.util.StringIntSizedMap;
import org.jibx.util.StringSizedSet;
/**
* Base class which provides validation hooks and support for extra namespaces. This base class for WSDL element
* representations is based on the schema data model code.
*
* @author Dennis M. Sosnoski
*/
public abstract class WsdlBase
{
/** Fixed URI for WSDL namespace. */
public static final String WSDL_NAMESPACE_URI = "http://schemas.xmlsoap.org/wsdl/";
/** Fixed URI for SOAP namespace. */
public static final String SOAP_NAMESPACE_URI = "http://schemas.xmlsoap.org/wsdl/soap/";
/** Extension data for application use. */
private Object m_extension;
/** Namespace definitions associated with this element (lazy create, null if unused). */
private List m_namespaces;
/** Documentation for component (lazy create, null if unused). */
private List m_documentation;
/**
* Get extension data. The actual type of object used for extension data (if any) is defined by the application.
*
* @return extension
*/
public Object getExtension() {
return m_extension;
}
/**
* Set extension data. The actual type of object used for extension data (if any) is defined by the application.
*
* @param extension
*/
public void setExtension(Object extension) {
m_extension = extension;
}
/**
* Get namespace declarations list. Entries in this list consist of pairs, consisting of namespace prefix followed
* by namespace URI. The empty string is used as the prefix for the default namespace.
*
* @return extra attribute list
*/
public final List getNamespaceDeclarations() {
if (m_namespaces == null || m_namespaces.size() == 0) {
return EmptyArrayList.INSTANCE;
} else {
return m_namespaces;
}
}
/**
* Clear namespace declarations list.
*/
public final void clearNamespaceDeclarations() {
if (m_namespaces != null) {
m_namespaces.clear();
}
}
/**
* Add namespace declaration.
*
* @param prefix namespace prefix
* @param uri namespace URI
*/
public final void addNamespaceDeclaration(String prefix, String uri) {
if (m_namespaces == null) {
m_namespaces = new ArrayList();
}
m_namespaces.add(prefix);
m_namespaces.add(uri);
}
/**
* Get documentation. This is the content of the optional <documentation> child element, which consists of DOM
* Nodes.
*
* @return documentation (null if no documentation present)
*/
public List getDocumentation() {
return m_documentation;
}
/**
* Set documentation. This is the content of the optional <documentation> child element, which consists of DOM
* Nodes.
*
* @param documentation
*/
public void setDocumentation(List documentation) {
m_documentation = documentation;
}
/**
* Pre-get method to be called by data binding while writing element start tag. The base class implementation just
* writes out any extra namespaces defined on the element. Subclasses which override this implementation must call
* the base implementation during their processing.
*
* @param ictx marshalling context
* @throws JiBXException on marshalling error
*/
protected void preget(IMarshallingContext ictx) throws JiBXException {
writeNamespaces(ictx);
}
/**
* Pre-set method to be called by data binding while parsing element start tag. The base class implementation just
* reads in any extra namespaces defined on the element. Subclasses which override this implementation must call the
* base implementation during their processing.
*
* @param ictx unmarshalling context
* @throws JiBXException on error
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
readNamespaces(ictx);
}
/**
* Validate attributes of element. This is designed to be called during unmarshalling as part of the pre-set method
* processing when a subclass instance is being created. An error is reported if an element in the default namespace
* is not in the declared list,
*
* @param ictx unmarshalling context
* @param other attributes from other namespaces allowed flag
* @param attrs attributes array
* @see #preset(IUnmarshallingContext)
*/
protected void validateAttributes(IUnmarshallingContext ictx, boolean other, StringArray attrs) {
// loop through all attributes of current element
UnmarshallingContext uctx = (UnmarshallingContext)ictx;
for (int i = 0; i < uctx.getAttributeCount(); i++) {
String name = uctx.getAttributeName(i);
String ns = uctx.getAttributeNamespace(i);
if (ns == null || ns.length() == 0) {
// check if no-namespace attribute in allowed set
if (attrs.indexOf(name) < 0) {
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
vctx.addError("Undefined attribute " + name, ictx.getStackTop());
}
} else if (WSDL_NAMESPACE_URI.equals(ns)) {
// no unknown attributes from definition namespace are defined
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
vctx.addError("Undefined attribute " + name, ictx.getStackTop());
} else if (!other) {
// warn on non-WSDL attribute present where forbidden
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
String qname = UnmarshallingContext.buildNameString(ns, name);
vctx.addWarning("Non-WSDL attribute not allowed " + qname, ictx.getStackTop());
}
}
}
/**
* Collect namespace declarations from element. This is designed to be called during unmarshalling as part of the
* pre-set method processing when a subclass instance is being created.
*
* @param ictx unmarshalling context
*/
protected void readNamespaces(IUnmarshallingContext ictx) {
UnmarshallingContext ctx = (UnmarshallingContext)ictx;
int count = ctx.getNamespaceCount();
if (count > 0) {
m_namespaces = new ArrayList();
for (int i = 0; i < count; i++) {
String pref = ctx.getNamespacePrefix(i);
if (pref == null) {
pref = "";
}
m_namespaces.add(pref);
m_namespaces.add(ctx.getNamespaceUri(i));
}
} else {
m_namespaces = null;
}
}
/**
* Create a unique prefix. If the requested prefix is already in use, this modifies the prefix by appending a
* numeric suffix to create a unique variant.
*
* @param pref requested prefix
* @param prefixes prefixes in use
* @return unique prefix
*/
private String makeUniquePrefix(String pref, StringSizedSet prefixes) {
int loop = 0;
while (prefixes.contains(pref)) {
pref = pref + loop;
}
prefixes.add(pref);
return pref;
}
/**
* Write namespace declarations to element. This is designed to be called during marshalling as part of the pre-get
* method processing when a subclass instance is being marshalled.
*
* @param ictx marshalling context
* @throws JiBXException on error writing
*/
protected void writeNamespaces(IMarshallingContext ictx) throws JiBXException {
if (m_namespaces != null) {
try {
// build sets of namespace uris and prefixes
IXMLWriter writer = ictx.getXmlWriter();
int curcnt = writer.getNamespaceCount();
StringIntSizedMap uriindexes = new StringIntSizedMap(curcnt);
int defcnt = m_namespaces.size() / 2;
StringSizedSet prefixes = new StringSizedSet(curcnt + defcnt);
for (int i = 0; i < curcnt; i++) {
uriindexes.add(writer.getNamespaceUri(i), i);
String prefix = writer.getNamespacePrefix(i);
if (prefix != null && prefix.length() > 0) {
prefixes.add(prefix);
}
}
// check namespace declarations on this element against writer state
List uris = new ArrayList();
GrowableIntArray indexes = new GrowableIntArray();
GrowableStringArray prefs = new GrowableStringArray();
int base = writer.getNamespaceCount();
for (int i = 0; i < defcnt; i++) {
String pref = (String)m_namespaces.get(i * 2);
String uri = (String)m_namespaces.get(i * 2 + 1);
int index = uriindexes.get(uri);
if (index >= 0) {
if (writer.getNamespacePrefix(index) == null) {
indexes.add(index);
prefs.add(makeUniquePrefix(pref, prefixes));
}
} else {
indexes.add(base + uris.size());
prefs.add(makeUniquePrefix(pref, prefixes));
uris.add(uri);
}
}
// add the namespace declarations to current element
writer.pushExtensionNamespaces((String[])uris.toArray(new String[uris.size()]));
writer.openNamespaces(indexes.toArray(), prefs.toArray());
for (int i = 0; i < prefs.size(); i++) {
String prefix = prefs.get(i);
String name = prefix.length() > 0 ? "xmlns:" + prefix : "xmlns";
writer.addAttribute(0, name, writer.getNamespaceUri(indexes.get(i)));
}
} catch (IOException e) {
throw new JiBXException("Error writing output document", e);
}
}
}
/**
* Prevalidate component information. The prevalidation step is used to check isolated aspects of a component, such
* as the settings for enumerated values. This empty base class implementation should be overridden by each subclass
* that requires prevalidation handling.
*
* @param vctx validation context
*/
public void prevalidate(ValidationContext vctx) {}
/**
* Validate component information. The validation step is used for checking the interactions between components,
* such as name references to other components. The {@link #prevalidate} method will always be called for every
* component in the schema definition before this method is called for any component. This empty base class
* implementation should be overridden by each subclass that requires validation handling.
*
* @param vctx validation context
*/
public void validate(ValidationContext vctx) {}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/tools/ 0000755 0001750 0001750 00000000000 11526304014 022405 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/tools/WsdlGeneratorCommandLine.java 0000644 0001750 0001750 00000021430 11331414066 030142 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.tools;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.jibx.custom.classes.GlobalCustom;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IUnmarshallable;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.generator.SchemaGenCommandLine;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.IClassLocator;
import org.jibx.util.ReflectionUtilities;
import org.jibx.ws.wsdl.tools.custom.WsdlCustom;
/**
* Command line processing specifically for the {@link Jibx2Wsdl} class.
*
* @author Dennis M. Sosnoski
*/
public class WsdlGeneratorCommandLine extends SchemaGenCommandLine
{
/** Ordered array of extra usage lines. */
private static final String[] EXTRA_USAGE_LINES =
new String[] { " -b generated root binding name (default is 'binding.xml')",
" -d use pure doc/lit (not wrapped) style",
" -u binding,...;schema,... existing bindings and schemas (separated by\n" +
" semicolon) to be used for messages (referenced schemas are included\n" +
" in WSDL)",
" -x class,... names of extra classes to be included in binding" };
/** Global customizations model root. */
private GlobalCustom m_global;
/** WSDL customizations model root. */
private WsdlCustom m_wsdlCustom;
/** List of extra classes for binding. */
private List m_extraTypes = new ArrayList();
/** List of existing bindings for messages. */
private List m_useBindings = new ArrayList();
/** List of existing schemas for messages. */
private List m_useSchemas = new ArrayList();
/** Name used for root binding. */
private String m_bindingName = "binding.xml";
/** Pure doc/lit (not wrapped) flag. */
private boolean m_docLit;
/**
* Constructor.
*/
public WsdlGeneratorCommandLine() {
super(EXTRA_USAGE_LINES);
}
/**
* Get customizations model root.
*
* @return customizations
*/
public GlobalCustom getGlobal() {
return m_global;
}
/**
* Get WSDL customizations model root.
*
* @return WSDL customizations
*/
public WsdlCustom getWsdlCustom() {
return m_wsdlCustom;
}
/**
* Get binding name.
*
* @return name
*/
public String getBindingName() {
return m_bindingName;
}
/**
* Get extra classes to be included in binding.
*
* @return list
*/
public List getExtraTypes() {
return m_extraTypes;
}
/**
* Get existing bindings to be used for message components.
*
* @return list
*/
public List getUseBindings() {
return m_useBindings;
}
/**
* Get existing schemas to be used for message components.
*
* @return list
*/
public List getUseSchemas() {
return m_useSchemas;
}
/**
* Check if using pure doc/lit (not wrapped) style.
*
* @return true if doc/lit, false if not
*/
public boolean isDocLit() {
return m_docLit;
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.CustomizationCommandLineBase#checkParameter(org.jibx.binding.generator.CustomizationCommandLineBase.ArgList)
*/
protected boolean checkParameter(ArgList alist) {
String arg = alist.current();
boolean match = true;
if ("-b".equalsIgnoreCase(arg)) {
m_bindingName = alist.next();
} else if ("-d".equalsIgnoreCase(arg)) {
m_docLit = true;
} else if ("-u".equalsIgnoreCase(arg)) {
String text = alist.next();
int split = text.indexOf(';');
if (split >= 0) {
splitItems(text.substring(split+1), m_useSchemas);
text = text.substring(0, split);
}
splitItems(text, m_useBindings);
} else if ("-x".equalsIgnoreCase(arg)) {
String text = alist.next();
if (text != null) {
int split;
int base = 0;
while ((split = text.indexOf(',', base)) > 0) {
m_extraTypes.add(text.substring(base, split));
base = split + 1;
}
m_extraTypes.add(text.substring(base));
}
} else {
match = super.checkParameter(alist);
}
return match;
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.CustomizationCommandLineBase#loadCustomizations(String,IClassLocator,org.jibx.schema.validation.ValidationContext)
*/
protected void loadCustomizations(String path, IClassLocator loc, ValidationContext vctx)
throws JiBXException, IOException {
// load or create customization information
setLocator(loc);
m_global = new GlobalCustom(loc);
if (path == null) {
m_global.setAddConstructors(true);
m_global.setForceClasses(true);
m_global.setMapAbstract(Boolean.TRUE);
} else {
IBindingFactory fact = BindingDirectory.getFactory(WsdlCustom.class);
IUnmarshallingContext ictx = fact.createUnmarshallingContext();
FileInputStream is = new FileInputStream(path);
ictx.setDocument(is, null);
ictx.setUserContext(vctx);
((IUnmarshallable)m_global).unmarshal(ictx);
}
// find or build WSDL customization
WsdlCustom custom = null;
List extens = m_global.getExtensionChildren();
for (Iterator iter = extens.iterator(); iter.hasNext();) {
Object exten = iter.next();
if (exten instanceof WsdlCustom) {
custom = (WsdlCustom)exten;
break;
}
}
if (custom == null) {
custom = new WsdlCustom(m_global);
m_global.addExtensionChild(custom);
}
m_wsdlCustom = custom;
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.CustomizationCommandLineBase#applyOverrides(Map)
*/
protected Map applyOverrides(Map overmap) {
Map unknowns = ReflectionUtilities.applyKeyValueMap(overmap, m_global);
unknowns = ReflectionUtilities.applyKeyValueMap(unknowns, m_wsdlCustom);
m_global.initClasses();
m_global.fillClasses();
return unknowns;
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.CustomizationCommandLineBase#printUsage()
*/
public void printUsage() {
System.out.println("\nUsage: java org.jibx.wsdl.Jibx2Wsdl " + "[options] class1 class2 ...\nwhere options are:");
String[] usages = getUsageLines();
for (int i = 0; i < usages.length; i++) {
System.out.println(usages[i]);
}
System.out.println("The class# files are different classes to be exposed as "
+ "services (references\nfrom these classes will automatically be "
+ "included in the generated bindings).\n");
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/tools/custom/ 0000755 0001750 0001750 00000000000 11526304014 023717 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/tools/custom/FaultCustom.java 0000644 0001750 0001750 00000014177 11124146372 027047 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.tools.custom;
import java.util.Collection;
import java.util.List;
import org.jibx.custom.classes.CustomBase;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
import org.jibx.util.IClassLocator;
import org.jibx.util.Types;
/**
* Fault data customization information.
* TODO: include this in the customizations file structure - child of service element?
*
* @author Dennis M. Sosnoski
*/
public class FaultCustom extends CustomBase
{
// fault data customization information
private String m_exceptionType;
private String m_fieldName;
private String m_dataType;
private String m_faultName;
private String m_elementName;
private List m_documentation;
/**
* Constructor.
*
* @param parent
* @param type fully-qualified exception class name
*/
protected FaultCustom(NestingBase parent, String type) {
super(parent);
m_exceptionType = type;
}
/**
* Get fully-qualified exception class name.
*
* @return type
*/
public String getExceptionType() {
return m_exceptionType;
}
/**
* Get Fault name. This method should only be used after the {@link #apply(IClassLocator)} method is called.
*
* @return parmaterized type
*/
public String getFaultName() {
return m_faultName;
}
/**
* Get XML element name for exception data. This method should only be used after the {@link #apply(IClassLocator)}
* method is called.
*
* @return name
*/
public String getElementName() {
return m_elementName;
}
/**
* Get fully-qualified name of exception data class.
*
* @return parmaterized type
*/
public String getDataType() {
return m_dataType;
}
/**
* Get value documentation node list. This method should only be used after the {@link #apply(IClassLocator)} method
* is called.
*
* @return list of documentation nodes (null if none)
*/
public List getDocumentation() {
return m_documentation;
}
/**
* Apply customizations to fault to fill out members.
*
* @param icl class locator
*/
public void apply(IClassLocator icl) {
String simple = m_exceptionType.substring(m_exceptionType.lastIndexOf('.') + 1);
if (simple.endsWith("Exception")) {
simple = simple.substring(0, simple.length() - 9);
}
if (m_elementName == null) {
m_elementName = getParent().convertName(simple);
}
if (m_faultName == null) {
m_faultName = m_elementName + "Fault";
}
IClass clas = icl.getRequiredClassInfo(m_exceptionType);
if (m_fieldName == null) {
IClassItem[] fields = clas.getFields();
for (int i = 0; i < fields.length; i++) {
IClassItem item = fields[i];
String type = item.getTypeName();
if (!Types.isSimpleValue(type)) {
IClass info = icl.getRequiredClassInfo(type);
if (info.isModifiable()) {
m_fieldName = item.getName();
m_dataType = type;
break;
}
}
}
if (m_fieldName == null) {
throw new IllegalStateException("No data object field found for exception class " + m_exceptionType);
}
} else {
IClassItem field = clas.getField(m_fieldName);
if (field == null) {
throw new IllegalStateException("Field " + m_fieldName + " not found in exception class "
+ m_exceptionType);
} else {
m_dataType = field.getTypeName();
}
}
}
/**
* Parameter value unmarshalling factory. This gets the containing element and the name so that the standard
* constructor can be used.
*
* @param ictx
* @return created instance
* @throws JiBXException
*/
private static FaultCustom throwsFactory(IUnmarshallingContext ictx) throws JiBXException {
UnmarshallingContext uctx = (UnmarshallingContext)ictx;
Object parent = uctx.getStackTop();
int depth = 0;
if (parent instanceof Collection) {
parent = uctx.getStackObject(++depth);
}
return new FaultCustom((OperationCustom)parent, uctx.attributeText(null, "class"));
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/tools/custom/ThrowsCustom.java 0000644 0001750 0001750 00000007661 11124146372 027262 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.tools.custom;
import java.util.List;
import org.jibx.custom.classes.CustomBase;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.util.StringArray;
/**
* Method throws customization information. This just defines the actual exceptions to be handled for a method
*
* @author Dennis M. Sosnoski
*/
public class ThrowsCustom extends CustomBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes = new StringArray(new String[] { "class" });
// value customization information
private String m_type;
private List m_documentation;
/**
* Constructor.
*
* @param parent
* @param type fully-qualified class name thrown
*/
protected ThrowsCustom(NestingBase parent, String type) {
super(parent);
m_type = type;
}
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
*/
private void preSet(IUnmarshallingContext uctx) {
validateAttributes(uctx, s_allowedAttributes);
}
/**
* Get fully-qualified class name thrown.
*
* @return type
*/
public String getType() {
return m_type;
}
/**
* Get value documentation node list. This method should only be used after the {@link #complete(List)} method is
* called.
*
* @return list of documentation nodes (null if none)
*/
public List getDocumentation() {
return m_documentation;
}
/**
* Complete customization information using supplied default documentation.
*
* @param docs default documentation text (null if none)
*/
/* package */void complete(List docs) {
if (m_documentation == null) {
m_documentation = docs;
}
}
/**
* Parameter value unmarshalling factory. This gets the containing element and the name so that the standard
* constructor can be used.
*
* @param ictx
* @return created instance
* @throws JiBXException
*/
private static ThrowsCustom throwsFactory(IUnmarshallingContext ictx) throws JiBXException {
return new ThrowsCustom((OperationCustom)getContainingObject(ictx), ((UnmarshallingContext)ictx).attributeText(
null, "class"));
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/tools/custom/NestingBase.java 0000644 0001750 0001750 00000014711 11124146372 026775 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.tools.custom;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import org.jibx.custom.classes.CustomBase;
import org.jibx.custom.classes.SharedNestingBase;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.util.StringArray;
/**
* Base class for nested WSDL customizations that can contain other customizations.
*
* @author Dennis M. Sosnoski
*/
public abstract class NestingBase extends SharedNestingBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "service-base", "set-actions", "use-nillable", "wrapped" },
SharedNestingBase.s_allowedAttributes);
// values inherited through nesting
private Boolean m_wrapped;
private Boolean m_setActions;
private Boolean m_useNillable;
private String m_serviceBase;
// set of unique names at level
private final Map m_namedChildMap;
// TODO: add WSDL namespace prefix, schema namespace prefix, WSDL structuring
/**
* Constructor.
*
* @param parent
*/
public NestingBase(SharedNestingBase parent) {
super(parent);
m_namedChildMap = new HashMap();
}
//
// Getters for values inherited through nesting
/**
* Check wrapped flag.
*
* @return wrapped flag
*/
public boolean isWrapped() {
if (m_wrapped == null) {
if (this instanceof WsdlCustom || getParent() == null) {
return true;
} else {
return ((NestingBase)getParent()).isWrapped();
}
} else {
return m_wrapped.booleanValue();
}
}
/**
* Check if soapAction should be set.
*
* @return soapAction flag
*/
public boolean isSoapAction() {
if (m_setActions == null) {
if (this instanceof WsdlCustom || getParent() == null) {
return true;
} else {
return ((NestingBase)getParent()).isSoapAction();
}
} else {
return m_setActions.booleanValue();
}
}
/**
* Check if xsi:nillable should be used for optional values (rather than minOccurs='0').
*
* @return xsi:nillable flag
*/
public boolean isNillable() {
if (m_useNillable == null) {
if (this instanceof WsdlCustom || getParent() == null) {
return false;
} else {
return ((NestingBase)getParent()).isNillable();
}
} else {
return m_useNillable.booleanValue();
}
}
/**
* Get the service base address.
*
* @return base address
*/
public String getServiceBase() {
if (m_serviceBase == null) {
if (this instanceof WsdlCustom || getParent() == null) {
return "http://localhost:8080/axis2/services";
} else {
return ((NestingBase)getParent()).getServiceBase();
}
} else {
return m_serviceBase;
}
}
/**
* Get child by name.
*
* @param name
* @return named child, null if name not registered
*/
public CustomBase getChild(String name) {
return (CustomBase)m_namedChildMap.get(name);
}
/**
* Register a child name. If the base name supplied has already been used by a different child, the name will be
* modified by adding a numeric suffix to make it unique. Once a name has been registered for a child, calling this
* method again with that name is guaranteed to just return that same name. Depending on the nesting level, the type
* of child may take different forms. This doesn't care what the names represent, it just makes sure they're unique.
*
* @param base proposed name
* @param child named child
* @return allowed name
*/
public String registerName(String base, CustomBase child) {
int index = 0;
String name = base;
Object value;
while ((value = m_namedChildMap.get(name)) != null && value != child) {
name = base + ++index;
}
m_namedChildMap.put(name, child);
return name;
}
/**
* Get WSDL definitions namespace.
*
* @return WSDL namespace
*/
public abstract String getWsdlNamespace();
/**
* Gets the parent element link from the unmarshalling stack. This method is for use by factories during
* unmarshalling.
*
* @param ictx unmarshalling context
* @return containing class
*/
protected static SharedNestingBase getContainingClass(IUnmarshallingContext ictx) {
Object parent = ictx.getStackTop();
int depth = 0;
if (parent instanceof Collection) {
parent = ictx.getStackObject(++depth);
}
return (SharedNestingBase)parent;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/tools/custom/WsdlCustom.java 0000644 0001750 0001750 00000021724 11124146372 026701 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.tools.custom;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.jibx.custom.classes.IApply;
import org.jibx.custom.classes.IDocumentFormatter;
import org.jibx.custom.classes.SharedNestingBase;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.schema.generator.FormatterCache;
import org.jibx.util.IClassLocator;
import org.jibx.util.StringArray;
/**
* Global customization information for WSDL generation. This extends the binding customization model to include the
* information used for service definitions.
*
* @author Dennis M. Sosnoski
*/
public class WsdlCustom extends NestingBase implements IApply
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "wsdl-namespace" }, NestingBase.s_allowedAttributes);
/** Customization value from unmarshalling. */
private String m_wsdlNamespace;
/** List of Fault definitions. */
private final ArrayList m_faultList;
/** Map from fully-qualified class name to Fault information. */
private final Map m_faultMap;
/** List of services, in order added. */
private final ArrayList m_serviceList;
/** Map from fully-qualified class name to service information. */
private final Map m_serviceMap;
/** Class locator. */
private IClassLocator m_locator;
/** JavaDoc formatter instance cache. */
private FormatterCache m_formatCache;
/**
* Constructor.
*
* @param parent
*/
public WsdlCustom(SharedNestingBase parent) {
super(parent);
m_faultList = new ArrayList();
m_faultMap = new HashMap();
m_serviceList = new ArrayList();
m_serviceMap = new HashMap();
}
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
*/
private void preSet(IUnmarshallingContext uctx) {
validateAttributes(uctx, s_allowedAttributes);
}
/**
* Get the namespace for WSDL definitions of services.
*
* @return WSDL namespace (null if unspecified)
*/
public String getWsdlNamespace() {
return m_wsdlNamespace;
}
/**
* Set the namespace for WSDL definitions of services.
*
* @param uri WSDL namespace (null if to be derived from service class name)
*/
public void setWsdlNamespace(String uri) {
m_wsdlNamespace = uri;
}
/**
* Get list of Faults.
*
* @return fault list
*/
public List getFaults() {
return m_faultList;
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.SharedNestingBase#getNameStyle()
*/
public int getNameStyle() {
return CAMEL_CASE_NAMES;
}
/**
* Get fault customization information. This method should only be used after the {@link #apply(IClassLocator)}
* method is called.
*
* @param type fully qualified class name
* @return fault customization (null if none)
*/
public FaultCustom getFaultCustomization(String type) {
return (FaultCustom)m_faultMap.get(type);
}
/**
* Force fault customization information. This method should only be used after the {@link #apply(IClassLocator)}
* method is called. If the fault customization information has not previously been created, it will be created by
* this call.
*
* @param type fully qualified exception class name
* @return fault customization (null if none)
*/
public FaultCustom forceFaultCustomization(String type) {
FaultCustom fault = (FaultCustom)m_faultMap.get(type);
if (fault == null) {
fault = new FaultCustom(this, type);
fault.apply(m_locator);
m_faultMap.put(type, fault);
}
return fault;
}
/**
* Get list of services.
*
* @return service list
*/
public List getServices() {
return m_serviceList;
}
/**
* Get service customization information. This method should only be used after the {@link #apply(IClassLocator)}
* method is called.
*
* @param type fully qualified class name
* @return service customization (null if none)
*/
public ServiceCustom getServiceCustomization(String type) {
return (ServiceCustom)m_serviceMap.get(type);
}
/**
* Add new service customization. This creates the service customization, using defaults, and adds it to the
* internal structures. This method should only be used after first calling {@link #getServiceCustomization(String)}
* and obtaining a null result.
*
* @param type fully qualified class name
* @return service customization
*/
public ServiceCustom addServiceCustomization(String type) {
ServiceCustom service = new ServiceCustom(this, type);
service.apply(m_locator, getFormatter(service));
m_serviceList.add(service);
m_serviceMap.put(type, service);
return service;
}
/**
* Get a JavaDoc formatter instance for a class.
*
* @param custom customization information
* @return formatter
*/
public IDocumentFormatter getFormatter(SharedNestingBase custom) {
return m_formatCache.getFormatter(custom);
}
/**
* Unmarshalling factory. This gets the containing element and the name so that the standard constructor can be
* used.
*
* @param ictx
* @return created instance
*/
private static WsdlCustom factory(IUnmarshallingContext ictx) {
return new WsdlCustom((SharedNestingBase)getContainingObject(ictx));
}
/**
* Apply customizations to services to fill out members.
*
* @param icl class locator
*/
public void apply(IClassLocator icl) {
// save locator for later use (when services are added)
m_locator = icl;
m_formatCache = new FormatterCache(icl);
// inherit namespace directly from package level, if not specified
String ns = getSpecifiedNamespace();
if (ns == null) {
ns = getParent().getNamespace();
}
setNamespace(ns);
// fix Faults and create map
for (int i = 0; i < m_faultList.size(); i++) {
FaultCustom fault = (FaultCustom)m_faultList.get(i);
fault.apply(icl);
m_faultMap.put(fault.getExceptionType(), fault);
}
// register services with names supplied (priority over generated names)
for (int i = 0; i < m_serviceList.size(); i++) {
ServiceCustom service = (ServiceCustom)m_serviceList.get(i);
String name = service.getServiceName();
if (name != null) {
if (registerName(name, service) != name) {
throw new IllegalStateException("Duplicate service name " + name);
}
}
}
// fix services and create map
for (int i = 0; i < m_serviceList.size(); i++) {
// TODO: this largely duplicates addServiceCustomization() - are both necessary?
ServiceCustom service = (ServiceCustom)m_serviceList.get(i);
service.apply(icl, getFormatter(service));
m_serviceMap.put(service.getClassName(), service);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/tools/custom/ValueCustom.java 0000644 0001750 0001750 00000017500 11414043712 027035 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.tools.custom;
import java.util.List;
import org.apache.log4j.Logger;
import org.jibx.custom.classes.SharedValueBase;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.util.IClass;
import org.jibx.util.StringArray;
/**
* Method parameter or return value customization information.
*
* @author Dennis M. Sosnoski
*/
public class ValueCustom extends SharedValueBase
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(ValueCustom.class.getName());
/** Style for elements used to wrap parameter values in request element. */
private static final Integer ELEMENT_STYLE = new Integer(org.jibx.custom.classes.NestingBase.ELEMENT_VALUE_STYLE);
/** Enumeration of allowed attribute names. */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "element", "name" }, SharedValueBase.s_allowedAttributes);
//
// Internal instance data
private String m_boundType; // internal use, not included in binding
/** Documentation text (as org.w3.dom.Node components). */
private List m_documentation;
/**
* Constructor.
*
* @param parent
* @param name
*/
protected ValueCustom(NestingBase parent, String name) {
super(parent, name);
}
/**
* Get value type to be bound. This is the same as the plain value type for a simple (non-collection); for an array
* value, it's just the array item type; and for a non-array collection it takes the same form as a generic type
* declaration, with the actual item type enclosed in a less-than/greater-than sign pair following the base type.
*
* @return parmaterized type
*/
public String getBoundType() {
return m_boundType;
}
/**
* Get value documentation node list. This method should only be used after the
* {@link #complete(IClass, List, Boolean, String)} method is called.
*
* @return list of documentation nodes (null if none)
*/
public List getDocumentation() {
return m_documentation;
}
/**
* Complete customization information based on supplied type. If the type information has not previously been set,
* this will set it. It will also derive the appropriate XML name, if not previously set.
*
* @param info value type information
* @param docs default documentation text (null if none)
* @param req required member flag (null if unspecified)
* @param itype item type from signature (null if unknown)
*/
/* package */void complete(IClass info, List docs, Boolean req, String itype) {
if (s_logger.isDebugEnabled()) {
StringBuffer buff = new StringBuffer();
if (getBaseName() == null) {
buff.append("Completing return value");
} else {
buff.append("Completing value ");
buff.append(getBaseName());
}
s_logger.debug(buff.toString());
}
fillType(info, req, ELEMENT_STYLE);
if (isCollection()) {
// make sure the item type is set
if (getItemType() == null) {
String tname = getWorkingType();
if (tname.endsWith("[]")) {
// set item type directly from array type
setItemType(tname.substring(0, tname.length() - 2));
} else if (itype != null) {
// set item type from signature
setItemType(itype);
} else {
setItemType("java.lang.Object");
}
}
// derive the item name if not already set
if (getItemName() == null) {
setItemName(deriveItemName(getXmlName(), getItemType(), getParent().getNameStyle()));
}
// set type for binding definition
String type = info.getName();
if (itype == null) {
if (type.endsWith("[]")) {
m_boundType = type.substring(0, type.length() - 2);
} else {
m_boundType = type;
}
} else {
m_boundType = type + '<' + itype + '>';
}
} else {
m_boundType = info.getName();
}
}
/**
* Make sure all attributes are defined when unmarshalling (only used by binding).
*
* @param uctx unmarshalling context
*/
protected void preSet(IUnmarshallingContext uctx) {
validateAttributes(uctx, s_allowedAttributes);
}
/**
* Set element name method. This is intended for use during unmarshalling, so it needs to allow for being called
* with a null value.
*
* @param text (null if attribute not present)
* @param ictx
*/
private void setElement(String text, IUnmarshallingContext ictx) {
if (text != null) {
setXmlName(text);
setElementForced();
setStyle(new Integer(org.jibx.custom.classes.NestingBase.ELEMENT_VALUE_STYLE));
}
}
/**
* Parameter value unmarshalling factory. This gets the containing element and the name so that the standard
* constructor can be used.
*
* @param ictx
* @return created instance
* @throws JiBXException
*/
private static ValueCustom parameterFactory(IUnmarshallingContext ictx) throws JiBXException {
String name = ((UnmarshallingContext)ictx).attributeText(null, "name");
s_logger.debug("Creating parameter instance with name " + name);
return new ValueCustom((OperationCustom)getContainingObject(ictx), name);
}
/**
* Return value unmarshalling factory. This gets the containing element so that the standard constructor can be
* used.
*
* @param ictx
* @return created instance
*/
private static ValueCustom returnFactory(IUnmarshallingContext ictx) {
return new ValueCustom((OperationCustom)getContainingObject(ictx), "return");
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/tools/custom/ServiceCustom.java 0000644 0001750 0001750 00000030762 11326333432 027371 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.tools.custom;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Logger;
import org.jibx.custom.CustomUtils;
import org.jibx.custom.classes.CustomBase;
import org.jibx.custom.classes.IDocumentFormatter;
import org.jibx.custom.classes.SharedNestingBase;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
import org.jibx.util.IClassLocator;
import org.jibx.util.StringArray;
/**
* Service customization information. This supports direct service customizations (such as the corresponding request
* and/or response element name) and also acts as a container for parameter and/or return customizations.
*
* @author Dennis M. Sosnoski
*/
public class ServiceCustom extends NestingBase
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(ServiceCustom.class.getName());
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "binding-name", "class", "excludes", "includes", "port-name", "port-type-name",
"service-address", "service-name", "wsdl-namespace" }, NestingBase.s_allowedAttributes);
// values specific to service level
private final String m_className;
private String m_serviceName;
private String m_portName;
private String m_bindingName;
private String m_portTypeName;
private String m_wsdlNamespace;
private String m_serviceAddress;
private List m_documentation;
private String[] m_includes;
private String[] m_excludes;
// list of contained operation customizations
private final ArrayList m_operations;
// values filled in by apply() method
private IClass m_classInformation;
private String m_namespace;
/**
* Constructor.
*
* @param parent
* @param clas
*/
public ServiceCustom(SharedNestingBase parent, String clas) {
super(parent);
m_className = clas;
m_operations = new ArrayList();
}
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
*/
private void preSet(IUnmarshallingContext uctx) {
validateAttributes(uctx, s_allowedAttributes);
}
/**
* Get service class name.
*
* @return class name
*/
public String getClassName() {
return m_className;
}
/**
* Get the service name.
*
* @return service name
*/
public String getServiceName() {
return m_serviceName;
}
/**
* Get the port name.
*
* @return port name
*/
public String getPortName() {
return m_portName;
}
/**
* Get the binding name.
*
* @return binding name
*/
public String getBindingName() {
return m_bindingName;
}
/**
* Get the portType name.
*
* @return portType name
*/
public String getPortTypeName() {
return m_portTypeName;
}
/**
* Get the service address.
*
* @return service address
*/
public String getServiceAddress() {
return m_serviceAddress;
}
/**
* Get service documentation node list.
*
* @return list of documentation nodes (null if none)
*/
public List getDocumentation() {
return m_documentation;
}
/**
* Get list of method names to be excluded as operations.
*
* @return excludes (null if none)
*/
public String[] getExcludes() {
return m_excludes;
}
/**
* Get list of method names to be included as operations.
*
* @return includes (null if none)
*/
public String[] getIncludes() {
return m_includes;
}
/**
* Get list of children.
*
* @return list
*/
public ArrayList getOperations() {
return m_operations;
}
/**
* Get the namespace for WSDL definitions of this service. This value is set by the {@link #apply(IClassLocator)}
* method.
*
* @return WSDL namespace
*/
public String getWsdlNamespace() {
return m_wsdlNamespace;
}
/**
* Add child.
*
* @param child
*/
protected void addChild(CustomBase child) {
if (child.getParent() == this) {
m_operations.add(child);
} else {
throw new IllegalStateException("Internal error: child not linked");
}
}
/**
* Unmarshalling factory. This gets the containing element and the name so that the standard constructor can be
* used.
*
* @param ictx
* @return created instance
* @throws JiBXException
*/
private static ServiceCustom factory(IUnmarshallingContext ictx) throws JiBXException {
String clas = ((UnmarshallingContext)ictx).attributeText(null, "class");
s_logger.debug("Creating instance for class " + clas);
return new ServiceCustom((SharedNestingBase)getContainingObject(ictx), clas);
}
/**
* Derive service-specific namespace URI. The appends the service name to the supplied URI, adding a path separator
* if necessary.
*
* @param uri base URI
* @return service-specific URI
*/
private String deriveServiceNamespace(String uri) {
if (!uri.endsWith("/")) {
uri = uri + '/';
}
uri = uri + m_serviceName;
return uri;
}
/**
* Apply customizations to service to fill out members.
*
* @param icl class locator
* @param fmt JavaDoc formatter
*/
public void apply(IClassLocator icl, IDocumentFormatter fmt) {
// find the service class information
m_classInformation = icl.getRequiredClassInfo(m_className);
// fill in any missing details
int split = m_className.lastIndexOf('.');
if (m_serviceName == null) {
String simple = m_className.substring(split + 1);
String name = convertName(simple, UPPER_CAMEL_CASE_NAMES);
m_serviceName = registerName(name, this);
s_logger.debug("Generated service name from class name: " + m_serviceName + " (base " + name + ')');
} else if (!m_serviceName.equals(registerName(m_serviceName, this))) {
throw new IllegalStateException("Service name conflict for '" + m_serviceName + '\'');
}
if (m_portName == null) {
m_portName = m_serviceName + "Port";
}
if (m_bindingName == null) {
m_bindingName = m_serviceName + "Binding";
}
if (m_portTypeName == null) {
m_portTypeName = m_serviceName + "PortType";
}
String uri = getSpecifiedNamespace();
if (uri == null) {
// append service name to inherited (or derived from package) setting
int style = getNamespaceStyle();
String base = uri = deriveNamespace(getParent().getNamespace(), m_classInformation.getPackage(), style);
if (style == DERIVE_BY_PACKAGE) {
uri = deriveServiceNamespace(base);
}
s_logger.debug("Generated service namespace URI: " + uri + " (base " + base + ')');
}
setNamespace(uri);
if (m_wsdlNamespace == null) {
// no WSDL namespace set, check parent setting
String ns = ((NestingBase)getParent()).getWsdlNamespace();
if (ns == null) {
// no setting, use class package and service name
m_wsdlNamespace = packageToNamespace(packageOfType(m_className)) + '/' + m_serviceName;
s_logger.debug("Generated WSDL namespace URI: " + m_wsdlNamespace);
} else {
// append service name to supplied setting
m_wsdlNamespace = deriveServiceNamespace(ns);
s_logger.debug("Derived WSDL namespace URI: " + m_wsdlNamespace);
}
}
if (m_serviceAddress == null) {
String base = getServiceBase();
if (base != null) {
StringBuffer buff = new StringBuffer(base);
if (!base.endsWith("/")) {
buff.append('/');
}
buff.append(m_serviceName);
m_serviceAddress = buff.toString();
s_logger.debug("Generated service address: " + m_serviceAddress);
}
}
if (m_documentation == null) {
m_documentation = fmt.docToNodes(m_classInformation.getJavaDoc());
}
// register any predefined operation children
for (int i = 0; i < m_operations.size(); i++) {
OperationCustom op = (OperationCustom)m_operations.get(i);
String name = op.getOperationName();
if (name != null) {
if (registerName(name, op) != name) {
throw new IllegalStateException("Duplicate operation name " + name);
}
}
}
// generate an operation for each exposed method in service class
Set inclset = CustomUtils.noCaseNameSet(m_includes);
Set exclset = CustomUtils.noCaseNameSet(m_excludes);
Map opmap = new HashMap();
for (int i = 0; i < m_operations.size(); i++) {
OperationCustom op = (OperationCustom)m_operations.get(i);
opmap.put(op.getMethodName().toLowerCase(), op);
s_logger.debug("Added operation " + op.getOperationName());
}
IClassItem[] methods = m_classInformation.getMethods();
for (int i = 0; i < methods.length; i++) {
IClassItem method = methods[i];
String name = method.getName();
String lcname = name.toLowerCase();
int access = method.getAccessFlags();
OperationCustom op = (OperationCustom)opmap.get(lcname);
if (op == null) {
if (!Modifier.isStatic(access) && !Modifier.isTransient(access) && !"".equals(name)) {
boolean use = true;
if (inclset != null) {
use = inclset.contains(lcname);
} else if (exclset != null) {
use = !exclset.contains(lcname);
}
if (use) {
op = new OperationCustom(this, name);
m_operations.add(op);
s_logger.debug("Generated operation for method " + name);
}
}
}
if (op != null) {
op.apply(method, icl, fmt);
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/tools/custom/OperationCustom.java 0000644 0001750 0001750 00000035232 11311545070 027723 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.tools.custom;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Logger;
import org.jibx.custom.CustomUtils;
import org.jibx.custom.classes.CustomBase;
import org.jibx.custom.classes.IDocumentFormatter;
import org.jibx.custom.classes.SharedNestingBase;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
import org.jibx.util.IClassLocator;
import org.jibx.util.StringArray;
import org.jibx.ws.wsdl.tools.SignatureParser;
/**
* Operation customization information. This supports direct operation customizations (such as the corresponding request
* and/or response element name) and also acts as a container for parameter and/or return customizations.
*
* @author Dennis M. Sosnoski
*/
public class OperationCustom extends NestingBase
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(OperationCustom.class.getName());
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "method-name", "operation-name", "optionals", "request-message",
"request-wrapper", "requireds", "response-message", "response-wrapper", "soap-action" },
SharedNestingBase.s_allowedAttributes);
// values specific to class level
private String m_methodName;
private String m_operationName;
private String m_requestMessageName;
private String m_requestWrapperName;
private String m_responseMessageName;
private String m_responseWrapperName;
private String m_soapAction;
private List m_documentation;
private String[] m_requireds;
private String[] m_optionals;
// list of contained parameter customizations
private final ArrayList m_parameters;
// contained result customization (null if none)
private ValueCustom m_return;
// list of contained throws customizations
private final ArrayList m_throws;
/**
* Constructor.
*
* @param parent
* @param name method name
*/
OperationCustom(NestingBase parent, String name) {
super(parent);
m_methodName = name;
m_parameters = new ArrayList();
m_throws = new ArrayList();
}
/**
* Get the namespace for WSDL definitions of this service.
*
* @return WSDL namespace
*/
public String getWsdlNamespace() {
return ((NestingBase)getParent()).getWsdlNamespace();
}
/**
* Get method name.
*
* @return name
*/
public String getMethodName() {
return m_methodName;
}
/**
* Get the operation name.
*
* @return operation name
*/
public String getOperationName() {
return m_operationName;
}
/**
* Get request message name.
*
* @return name
*/
public String getRequestMessageName() {
return m_requestMessageName;
}
/**
* Get request wrapper element name.
*
* @return name
*/
public String getRequestWrapperName() {
return m_requestWrapperName;
}
/**
* Get response message name.
*
* @return name
*/
public String getResponseMessageName() {
return m_responseMessageName;
}
/**
* Get response wrapper name.
*
* @return name
*/
public String getResponseWrapperName() {
return m_responseWrapperName;
}
/**
* Get return value.
*
* @return return
*/
public ValueCustom getReturn() {
return m_return;
}
/**
* Get SOAPAction.
*
* @return soapAction
*/
public String getSoapAction() {
return m_soapAction;
}
/**
* Get operation documentation.
*
* @return list of documentation nodes (null if none)
*/
public List getDocumentation() {
return m_documentation;
}
/**
* Get list of children.
*
* @return list
*/
public ArrayList getParameters() {
return m_parameters;
}
/**
* Get list of throws customizations.
*
* @return list
*/
public ArrayList getThrows() {
return m_throws;
}
/**
* Add child.
*
* @param child
*/
protected void addChild(CustomBase child) {
if (child.getParent() == this) {
m_parameters.add(child);
} else {
throw new IllegalStateException("Internal error: child not linked");
}
}
/**
* Unmarshalling factory. This gets the containing element and the name so that the standard constructor can be
* used.
*
* @param ictx
* @return created instance
* @throws JiBXException
*/
private static OperationCustom factory(IUnmarshallingContext ictx) throws JiBXException {
String mname = ((UnmarshallingContext)ictx).attributeText(null, "method-name");
s_logger.debug("Creating operation for operation name " + mname);
return new OperationCustom((NestingBase)getContainingObject(ictx), mname);
}
/**
* Check if type is a collection type (specifically collection, not array).
*
* @param type
* @return item type, null if not a collection type
*/
private boolean isCollection(String type, IClassLocator icl) {
IClass info = icl.getRequiredClassInfo(type);
return info.isImplements("Ljava/util/Collection;");
}
/**
* Parse parameter type.
*
* @param parse
* @return parameter type
*/
private String parameterType(SignatureParser parse) {
String itype = null;
while (parse.next() != SignatureParser.TYPE_PARAMETERS_END_EVENT) {
if (itype == null && parse.getEvent() == SignatureParser.TYPE_EVENT) {
itype = parse.getType();
}
}
return itype;
}
/**
* Check if a particular value is required or optional.
*
* @param name
* @param reqset
* @param optset
* @return TRUE if required, FALSE if optional, null if unknown
*/
private static Boolean checkRequired(String name, Set reqset, Set optset) {
if (reqset != null && reqset.contains(name)) {
return Boolean.TRUE;
} else if (optset != null && optset.contains(name)) {
return Boolean.FALSE;
} else {
return null;
}
}
/**
* Apply customizations to method to fill out parameter and return information.
*
* @param method
* @param icl
* @param fmt
*/
public void apply(IClassItem method, IClassLocator icl, IDocumentFormatter fmt) {
// fill in missing details
s_logger.debug("Applying operation from method " + m_methodName);
if (m_operationName == null) {
String name = convertName(m_methodName, CAMEL_CASE_NAMES);
m_operationName = registerName(name, this);
s_logger.debug("Set operation name " + m_operationName);
} else if (!m_operationName.equals(registerName(m_operationName, this))) {
throw new IllegalStateException("Operation name conflict for '" + m_operationName + '\'');
}
if (m_requestMessageName == null) {
m_requestMessageName = m_operationName + "Message";
}
if (m_requestWrapperName == null) {
m_requestWrapperName = m_operationName;
}
if (m_responseMessageName == null) {
m_responseMessageName = m_operationName + "ResponseMessage";
}
if (m_responseWrapperName == null) {
m_responseWrapperName = m_operationName + "Response";
}
if (m_soapAction == null && isSoapAction()) {
m_soapAction = "urn:" + m_operationName;
}
if (m_documentation == null) {
m_documentation = fmt.docToNodes(method.getJavaDoc());
}
// find parameter types, and item types for collections
int count = method.getArgumentCount();
String[] ptypes = new String[count];
String[] pitypes = new String[count];
String rtype = null;
String ritype = null;
String sig = method.getGenericsSignature();
if (sig == null) {
// no signature, just use basic type information
for (int i = 0; i < count; i++) {
String type = method.getArgumentType(i);
ptypes[i] = type;
if (isCollection(type, icl)) {
pitypes[i] = "java.lang.Object";
}
}
rtype = method.getTypeName();
if (isCollection(rtype, icl)) {
ritype = "java.lang.Object";
}
} else {
// parse the signature to check collection item types
SignatureParser parse = new SignatureParser(sig);
int index = 0;
boolean inparms = false;
while (parse.next() != SignatureParser.END_EVENT) {
switch (parse.getEvent()) {
case SignatureParser.METHOD_PARAMETERS_START_EVENT:
inparms = true;
index = 0;
break;
case SignatureParser.METHOD_PARAMETERS_END_EVENT:
inparms = false;
break;
case SignatureParser.TYPE_EVENT:
String type = parse.getType();
String itype = null;
if (parse.isParameterized()) {
String ptype = parameterType(parse);
IClass info = icl.getRequiredClassInfo(type);
if (info.isImplements("Ljava/util/Collection;")) {
itype = ptype;
}
}
if (inparms) {
ptypes[index] = type;
pitypes[index++] = itype;
} else {
rtype = type;
ritype = itype;
}
break;
}
}
}
// create map of parameters using separate customizations
Map namevalue = new HashMap();
for (int i = 0; i < m_parameters.size(); i++) {
ValueCustom value = (ValueCustom)m_parameters.get(i);
namevalue.put(value.getBaseName(), value);
}
m_parameters.clear();
// fill in the parameters and return customizations
Set reqset = CustomUtils.noCaseNameSet(m_requireds);
Set optset = CustomUtils.noCaseNameSet(m_optionals);
for (int i = 0; i < count; i++) {
String name = method.getParameterName(i);
if (name == null) {
name = "arg" + (i + 1);
}
ValueCustom value = (ValueCustom)namevalue.get(name);
if (value == null) {
value = new ValueCustom(this, name);
s_logger.debug("Added customization for parameter " + name + " with type " + pitypes[i]);
} else {
s_logger.debug("Found customization for parameter " + name + " with type " + pitypes[i]);
}
m_parameters.add(value);
Boolean req = checkRequired(name, reqset, optset);
List docs = fmt.docToNodes(method.getParameterJavaDoc(i));
value.complete(icl.getRequiredClassInfo(ptypes[i]), docs, req, pitypes[i]);
}
Boolean req = checkRequired("return", reqset, optset);
String text = method.getReturnJavaDoc();
boolean isname = false;
if (text != null && Character.isJavaIdentifierStart(text.charAt(0))) {
isname = true;
for (int i = 1; i < text.length(); i++) {
if (!Character.isJavaIdentifierPart(text.charAt(i))) {
isname = false;
break;
}
}
}
String name = "return";
if (isname) {
name = text;
text = null;
}
List docs = fmt.docToNodes(text);
if (m_return == null) {
m_return = new ValueCustom(this, name);
}
m_return.complete(icl.getRequiredClassInfo(rtype), docs, req, ritype);
// add throws information
count = method.getExceptions().length;
if (m_throws.size() == 0) {
for (int i = 0; i < count; i++) {
name = method.getExceptions()[i];
ThrowsCustom thrw = new ThrowsCustom(this, name);
thrw.complete(fmt.docToNodes(method.getExceptionJavaDoc(i)));
m_throws.add(thrw);
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/tools/WsdlWriter.java 0000644 0001750 0001750 00000017006 11124146424 025365 0 ustar twerner twerner /*
* Copyright (c) 2004-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.tools;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IMarshallable;
import org.jibx.runtime.IMarshaller;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IXMLWriter;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.MarshallingContext;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.elements.SchemaElement;
import org.jibx.util.StringIntSizedMap;
import org.jibx.ws.wsdl.model.Definitions;
/**
* WSDL writer class. This handles writing generated WSDLs and schemas.
*
* @author Dennis M. Sosnoski
*/
public class WsdlWriter
{
/** Fixed URI for WSDL namespace. */
public static final String WSDL_NAMESPACE_URI = "http://schemas.xmlsoap.org/wsdl/";
/** Fixed prefix for WSDL namespace. */
public static final String WSDL_NAMESPACE_PREFIX = "wsdl";
/** Fixed URI for SOAP namespace. */
public static final String SOAP_NAMESPACE_URI = "http://schemas.xmlsoap.org/wsdl/soap/";
/** Fixed prefix for SOAP namespace. */
public static final String SOAP_NAMESPACE_PREFIX = "soap";
/** Fixed prefix for WSDL target namespace. */
public static final String DEFINITIONS_NAMESPACE_PREFIX = "wns";
/** Namespaces defined in binding. */
private StringIntSizedMap s_namespaceMap;
/** Namespace index for the WSDL namespace. */
private int s_wsdlNamespaceIndex;
/** Map from extra namespace URIs to prefixes. */
private Map m_uriPrefixMap;
/** Namespace index for the SOAP namespace. */
private int s_soapNamespaceIndex;
/** Marshalling context. */
private final MarshallingContext m_marshalContext;
/**
* Constructor.
*
* @throws JiBXException on error creating marshaller
*/
public WsdlWriter() throws JiBXException {
// set the marshalling contexts
IBindingFactory ifact = BindingDirectory.getFactory(Definitions.class);
m_marshalContext = (MarshallingContext)ifact.createMarshallingContext();
// initialize namespace URI to index map
String[] nss = ifact.getNamespaces();
s_namespaceMap = new StringIntSizedMap(nss.length);
for (int i = 0; i < nss.length; i++) {
s_namespaceMap.add(nss[i], i);
}
// create other statics used in code
s_wsdlNamespaceIndex = s_namespaceMap.get(WSDL_NAMESPACE_URI);
s_soapNamespaceIndex = s_namespaceMap.get(SOAP_NAMESPACE_URI);
}
/**
* Write WSDL for service to output stream.
*
* @param def WSDL definitions information
* @param os destination output stream
* @exception JiBXException on error creating WSDL output
*/
public void writeWSDL(Definitions def, OutputStream os) throws JiBXException {
// configure context for output stream
m_marshalContext.setOutput(os, null);
m_marshalContext.setIndent(2);
m_marshalContext.setUserContext(def);
// // set up information for namespace indexes and prefixes
// Set uriset = def.getNamespaces();
// String[] uris = new String[uriset.size()];
// int[] indexes = new int[uris.length + 2];
// String[] prefs = new String[uris.length + 2];
// IXMLWriter writer = m_marshalContext.getXmlWriter();
// int base = writer.getNamespaceCount();
// int index = 0;
// for (Iterator iter = uriset.iterator(); iter.hasNext();) {
// String uri = (String)iter.next();
// uris[index] = uri;
// indexes[index] = base + index;
// prefs[index++] = def.getPrefix(uri);
// }
// indexes[index] = s_wsdlNamespaceIndex;
// prefs[index++] = WSDL_NAMESPACE_PREFIX;
// indexes[index] = s_soapNamespaceIndex;
// prefs[index] = SOAP_NAMESPACE_PREFIX;
//
// // add the namespace declarations to current element
// writer.pushExtensionNamespaces(uris);
// /*
// * writer.openNamespaces(indexes, prefs); for (int i = 0; i < uris.length; i++) { String prefix = prefs[i];
// * String name = prefix.length() > 0 ? "xmlns:" + prefix : "xmlns"; writer.addAttribute(0, name, uris[i]); }
// */
//
// // write start tag with added namespaces
// m_marshalContext.startTagNamespaces(s_wsdlNamespaceIndex, "definitions", indexes, prefs);
// m_marshalContext.attribute(0, "targetNamespace", def.getWsdlNamespace());
// m_marshalContext.closeStartContent();
// marshal out remaining data
IMarshaller mar = m_marshalContext.getMarshaller(Definitions.class.getName());
mar.marshal(def, m_marshalContext);
m_marshalContext.endDocument();
//
// // finish with close tag
// m_marshalContext.endTag(s_wsdlNamespaceIndex, "definitions");
// m_marshalContext.endDocument();
}
public static class SchemaMarshaller implements IMarshaller
{
/** Marshalling context for schema. */
private final MarshallingContext m_schemaContext;
public SchemaMarshaller() throws JiBXException {
IBindingFactory ifact = BindingDirectory.getFactory(SchemaUtils.XS_PREFIX_BINDING, SchemaElement.class);
m_schemaContext = (MarshallingContext)ifact.createMarshallingContext();
}
public boolean isExtension(String mapname) {
return false;
}
public void marshal(Object obj, IMarshallingContext ctx) throws JiBXException {
try {
m_schemaContext.setFromContext((MarshallingContext)ctx);
((IMarshallable)obj).marshal(m_schemaContext);
m_schemaContext.getXmlWriter().flush();
} catch (IOException e) {
throw new JiBXException("Error writing schema", e);
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/tools/SignatureParser.java 0000644 0001750 0001750 00000021112 11124146424 026366 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.tools;
/**
* Pull parser for generic method or field signature.
*
* @author Dennis M. Sosnoski
*/
public class SignatureParser
{
//
// Signature events
public static final int END_EVENT = 0;
public static final int TYPE_EVENT = 1;
public static final int METHOD_PARAMETERS_START_EVENT = 2;
public static final int METHOD_PARAMETERS_END_EVENT = 3;
public static final int TYPE_PARAMETERS_START_EVENT = 4;
public static final int TYPE_PARAMETERS_END_EVENT = 5;
//
// Common types
private static final String STRING_SIGNATURE = "java/lang/String;";
private static final String STRING_TYPE = "java.lang.String";
private static final String OBJECT_SIGNATURE = "java/lang/Object;";
private static final String OBJECT_TYPE = "java.lang.Object";
//
// Instance data
private final String m_signature;
private int m_offset;
private int m_event;
private boolean m_isPrimitive;
private boolean m_isParameterized;
private String m_type;
/**
* Constructor.
*
* @param sig signature attribute value
*/
public SignatureParser(String sig) {
if (sig.startsWith("Signature(") && sig.endsWith(")")) {
m_signature = sig.substring(10, sig.length() - 1);
m_event = -1;
} else {
throw new IllegalArgumentException("Internal error: not a valid Signature");
}
}
/**
* Check if type is parameterized. It is an error to call this if the current event is not {@link #TYPE_EVENT}.
*
* @return true if parameterized type
*/
public boolean isParameterized() {
if (m_event == TYPE_EVENT) {
return m_isParameterized;
} else {
throw new IllegalStateException("Internal error: not at TYPE_EVENT");
}
}
/**
* Check if type is a primitive. It is an error to call this if the current event is not {@link #TYPE_EVENT}.
*
* @return true if primitive type
*/
public boolean isPrimitive() {
if (m_event == TYPE_EVENT) {
return m_isPrimitive;
} else {
throw new IllegalStateException("Internal error: not at TYPE_EVENT");
}
}
/**
* Get current event.
*
* @return event
*/
public int getEvent() {
return m_event;
}
/**
* Get type. It is an error to call this if the current event is not {@link #TYPE_EVENT}.
*
* @return type
*/
public String getType() {
if (m_event == TYPE_EVENT) {
return m_type;
} else {
throw new IllegalStateException("Internal error: not at TYPE_EVENT");
}
}
/**
* Get next parse event.
*
* @return event
*/
public int next() {
if (m_event == END_EVENT) {
throw new IllegalStateException("Internal error: cannot advance parser");
} else if (m_offset >= m_signature.length()) {
m_event = END_EVENT;
} else {
// assume next event is a primitive type, then correct if necessary
m_event = TYPE_EVENT;
m_isPrimitive = true;
m_isParameterized = false;
char chr = m_signature.charAt(m_offset++);
switch (chr) {
// blocking start/end characters
case '(':
m_event = METHOD_PARAMETERS_START_EVENT;
break;
case ')':
m_event = METHOD_PARAMETERS_END_EVENT;
break;
case '<':
m_event = TYPE_PARAMETERS_START_EVENT;
break;
case '>':
m_event = TYPE_PARAMETERS_END_EVENT;
if (m_offset < m_signature.length() && m_signature.charAt(m_offset) == ';') {
m_offset++;
}
break;
// primitive type indication characters
case 'B':
m_type = "byte";
break;
case 'C':
m_type = "char";
break;
case 'D':
m_type = "double";
break;
case 'F':
m_type = "float";
break;
case 'I':
m_type = "int";
break;
case 'J':
m_type = "long";
break;
case 'S':
m_type = "short";
break;
case 'V':
m_type = "void";
break;
case 'Z':
m_type = "boolean";
break;
// object type
case 'L': {
m_isPrimitive = false;
if (m_signature.startsWith(STRING_SIGNATURE, m_offset)) {
m_offset += STRING_SIGNATURE.length();
m_type = STRING_TYPE;
} else if (m_signature.startsWith(OBJECT_SIGNATURE, m_offset)) {
m_offset += OBJECT_SIGNATURE.length();
m_type = OBJECT_TYPE;
} else {
StringBuffer buff = new StringBuffer();
boolean done = false;
while (m_offset < m_signature.length()) {
chr = m_signature.charAt(m_offset++);
if (chr == '/') {
buff.append('.');
} else if (chr == ';') {
done = true;
break;
} else if (chr == '<') {
done = true;
m_offset--;
m_isParameterized = true;
break;
} else {
buff.append(chr);
}
}
if (!done) {
throw new IllegalStateException("Internal error: cannot interpret type");
} else {
m_type = buff.toString();
}
}
break;
}
// error if anything else
default:
throw new IllegalStateException("Internal error: signature parse state");
}
}
return m_event;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/ws/wsdl/tools/Jibx2Wsdl.java 0000644 0001750 0001750 00000125516 11414120732 025071 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.ws.wsdl.tools;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Logger;
import org.jibx.binding.generator.BindGen;
import org.jibx.binding.generator.BindingMappingDetail;
import org.jibx.binding.model.BindingElement;
import org.jibx.binding.model.BindingHolder;
import org.jibx.binding.model.CollectionElement;
import org.jibx.binding.model.ElementBase;
import org.jibx.binding.model.MappingElement;
import org.jibx.binding.model.MappingElementBase;
import org.jibx.custom.classes.ClassCustom;
import org.jibx.custom.classes.CustomBase;
import org.jibx.custom.classes.GlobalCustom;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.schema.IComponent;
import org.jibx.schema.ISchemaResolver;
import org.jibx.schema.MemoryResolver;
import org.jibx.schema.SchemaContextTracker;
import org.jibx.schema.SchemaHolder;
import org.jibx.schema.SchemaVisitor;
import org.jibx.schema.TreeWalker;
import org.jibx.schema.UrlResolver;
import org.jibx.schema.elements.AnnotationElement;
import org.jibx.schema.elements.ComplexTypeElement;
import org.jibx.schema.elements.DocumentationElement;
import org.jibx.schema.elements.ElementElement;
import org.jibx.schema.elements.SchemaBase;
import org.jibx.schema.elements.SchemaElement;
import org.jibx.schema.elements.SchemaLocationBase;
import org.jibx.schema.elements.SequenceElement;
import org.jibx.schema.generator.MappingDetail;
import org.jibx.schema.generator.SchemaGen;
import org.jibx.schema.types.Count;
import org.jibx.schema.validation.ProblemConsoleLister;
import org.jibx.schema.validation.ProblemLogLister;
import org.jibx.schema.validation.ProblemMultiHandler;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.schema.validation.ValidationProblem;
import org.jibx.schema.validation.ValidationUtils;
import org.jibx.util.DummyClassLocator;
import org.jibx.util.IClass;
import org.jibx.util.IClassLocator;
import org.jibx.util.InsertionOrderedSet;
import org.jibx.util.ResourceMatcher;
import org.jibx.util.Types;
import org.jibx.ws.wsdl.model.Definitions;
import org.jibx.ws.wsdl.model.Message;
import org.jibx.ws.wsdl.model.MessagePart;
import org.jibx.ws.wsdl.model.Operation;
import org.jibx.ws.wsdl.tools.custom.FaultCustom;
import org.jibx.ws.wsdl.tools.custom.OperationCustom;
import org.jibx.ws.wsdl.tools.custom.ServiceCustom;
import org.jibx.ws.wsdl.tools.custom.ThrowsCustom;
import org.jibx.ws.wsdl.tools.custom.ValueCustom;
import org.jibx.ws.wsdl.tools.custom.WsdlCustom;
import org.w3c.dom.Node;
/**
* Start-from-code WSDL generator using JiBX data binding. This starts from one or more service classes, each with one
* or more methods to be exposed as service operations, and generates complete bindings and WSDL for the services.
* Although many of the methods in this class use public access, they are intended for use only by the JiBX
* developers and may change from one release to the next. To make use of this class from your own code, call the {@link
* #main(String[])} method with an appropriate argument list.
*
* @author Dennis M. Sosnoski
*/
public class Jibx2Wsdl
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(Jibx2Wsdl.class.getName());
/** Parameter information for generation. */
private final WsdlGeneratorCommandLine m_generationParameters;
/** Binding generator. */
private final BindGen m_bindingGenerator;
/** Schema generator. */
private final SchemaGen m_schemaGenerator;
/** Map from schema namespace URIs to schema holders. */
private final Map m_uriSchemaMap;
/**
* Constructor.
*
* @param parms generation parameters
*/
private Jibx2Wsdl(WsdlGeneratorCommandLine parms) {
m_generationParameters = parms;
GlobalCustom global = parms.getGlobal();
m_bindingGenerator = new BindGen(global);
m_schemaGenerator = new SchemaGen(parms.getLocator(), global, parms.getUriNames());
m_uriSchemaMap = new HashMap();
}
/**
* Get the qualified name used for an abstract mapping. This throws an exception if the qualified name is not found.
*
* @param type
* @param mapping
* @return qualified name
*/
private QName getMappingQName(String type, MappingElement mapping) {
MappingDetail detail = m_schemaGenerator.getMappingDetail(mapping);
if (detail == null) {
throw new IllegalStateException("No mapping found for type " + type);
} else if (detail.isType()) {
return detail.getTypeName();
} else {
throw new IllegalStateException("Need abstract mapping for type " + type);
}
}
/**
* Add reference to another schema. The reference may either be to a definition in a supplied schema (in which case
* it'll be in the map) or in a generated schema (in which case the namespace is used to lookup the schema).
*
* @param qname referenced definition name
* @param namemap map from qualified name to holder for defining schema (only for predefined schemas)
* @param holder schema making the reference
*/
private void addSchemaReference(QName qname, Map namemap, SchemaHolder holder) {
if (qname != null && !IComponent.SCHEMA_NAMESPACE.equals(qname.getUri())) {
SchemaHolder target = (SchemaHolder)namemap.get(qname);
if (target == null) {
target = (SchemaHolder)m_uriSchemaMap.get(qname.getUri());
}
holder.addReference(target);
}
}
/**
* Build an element representing a parameter or return value.
*
* @param parm
* @param typemap map from parameterized type to abstract mapping qualified name
* @param namemap map from qualified name to holder for defining schema (only for predefined schemas)
* @param hold containing schema holder
* @return constructed element
*/
private ElementElement buildValueElement(ValueCustom parm, Map typemap, Map namemap, SchemaHolder hold) {
// create the basic element definition
ElementElement elem = new ElementElement();
if (!parm.isRequired()) {
elem.setMinOccurs(Count.COUNT_ZERO);
}
String type = parm.getWorkingType();
boolean repeat = false;
// check type or reference for element
boolean isref = false;
String ptype = parm.getBoundType();
QName tname = (QName)typemap.get(ptype);
if (tname == null) {
// no mapped handling, so check first for object type parameter with corresponding schema type (byte[])
tname = Types.schemaType(type);
if (tname == null && (tname = Types.schemaType(ptype)) == null) {
// must be either an array collection, or a reference
repeat = parm.isCollection();
String usetype = ptype.endsWith(">") ? type : ptype;
BindingMappingDetail detail = m_bindingGenerator.getMappingDetail(usetype);
if (detail == null) {
throw new IllegalStateException("No mapping found for type " + usetype);
} else if (detail.isExtended()) {
elem.setRef(detail.getElementQName());
isref = true;
} else {
MappingElement mapping = detail.getAbstractMapping();
tname = mapping.getTypeQName();
if (tname == null) {
tname = getMappingQName(usetype, mapping);
}
}
}
}
if (isref) {
addSchemaReference(elem.getRef(), namemap, hold);
} else {
// set element type and name
m_schemaGenerator.setElementType(tname, elem, hold);
String ename = parm.getXmlName();
if (ename == null) {
ename = tname.getName();
}
elem.setName(ename);
addSchemaReference(tname, namemap, hold);
}
// handle repeated value
if (repeat) {
elem.setMaxOccurs(Count.COUNT_UNBOUNDED);
}
// add documentation if available
List nodes = parm.getDocumentation();
if (nodes != null) {
AnnotationElement anno = new AnnotationElement();
DocumentationElement doc = new DocumentationElement();
for (Iterator iter = nodes.iterator(); iter.hasNext();) {
Node node = (Node)iter.next();
doc.addContent(node);
}
anno.getItemsList().add(doc);
elem.setAnnotation(anno);
}
return elem;
}
/**
* Build WSDL for service.
*
* @param service
* @param ptypemap map from parameterized type to abstract mapping name
* @param classelems fully-qualified class name to element qualified name map
* @param elemschemas element qualified name to schema holder map
* @param classtypes fully-qualified class name to type qualified name map
* @param typeschemas type qualified name to schema holder map
* @return constructed WSDL definitions
*/
private Definitions buildWSDL(ServiceCustom service, Map ptypemap, Map classelems, Map elemschemas, Map classtypes,
Map typeschemas) {
// initialize root object of definition
String wns = service.getWsdlNamespace();
Definitions def = new Definitions(service.getPortTypeName(), service.getBindingName(), service.getServiceName(),
service.getPortName(), "tns", wns);
def.setServiceLocation(service.getServiceAddress());
// add service documentation if available
IClassLocator locator = m_generationParameters.getLocator();
IClass info = locator.getClassInfo(service.getClassName());
if (info != null) {
List nodes = m_generationParameters.getWsdlCustom().getFormatter(service).docToNodes(info.getJavaDoc());
def.setPortTypeDocumentation(nodes);
}
// find or create the schema element and namespace
String sns = service.getNamespace();
SchemaHolder holder = m_schemaGenerator.findSchema(sns);
SchemaElement schema = holder.getSchema();
// process messages and operations used by service
ArrayList ops = service.getOperations();
Map fltmap = new HashMap();
Set imports = new InsertionOrderedSet();
Map typemap = new HashMap(ptypemap);
for (int i = 0; i < ops.size(); i++) {
// get information for operation
OperationCustom odef = (OperationCustom)ops.get(i);
String oname = odef.getOperationName();
Operation op = new Operation(oname);
op.setDocumentation(odef.getDocumentation());
op.setSoapAction(odef.getSoapAction());
// generate input message information
Message rqmsg = new Message(odef.getRequestMessageName(), wns);
op.addInputMessage(rqmsg);
def.addMessage(rqmsg);
QName rqelem = null;
if (m_generationParameters.isDocLit()) {
// check if input parameter defined for method
ArrayList parms = odef.getParameters();
if (parms.size() > 0) {
// check for existing element definition matching the parameter type
ValueCustom parm = (ValueCustom)parms.get(0);
rqelem = (QName)classelems.get(parm.getWorkingType());
if (rqelem == null) {
// create new element for parameter
ElementElement pelem = buildValueElement(parm, ptypemap, typeschemas, holder);
schema.getTopLevelChildren().add(pelem);
rqelem = pelem.getQName();
} else {
// import and use existing element definition
imports.add(elemschemas.get(rqelem));
addSchemaReference(rqelem, elemschemas, holder);
}
}
} else {
// construct a sequence for wrapped method parameters
SequenceElement seq = new SequenceElement();
ArrayList parms = odef.getParameters();
for (int j = 0; j < parms.size(); j++) {
ValueCustom parm = (ValueCustom)parms.get(j);
String type = parm.getWorkingType();
ElementElement pelem;
if (!typemap.containsKey(type)) {
// add predefined mapping type to known types and require schema import
QName tname = (QName)classtypes.get(type);
if (tname != null) {
typemap.put(type, tname);
imports.add(typeschemas.get(tname));
}
}
pelem = buildValueElement(parm, ptypemap, typeschemas, holder);
seq.getParticleList().add(pelem);
}
// add corresponding schema definition to schema
ComplexTypeElement tdef = new ComplexTypeElement();
tdef.setContentDefinition(seq);
ElementElement elem = new ElementElement();
String wname = odef.getRequestWrapperName();
elem.setName(wname);
elem.setTypeDefinition(tdef);
schema.getTopLevelChildren().add(elem);
rqelem = new QName(sns, wname);
}
// add part definition to message (if present)
if (rqelem != null) {
MessagePart part = new MessagePart("part", rqelem);
rqmsg.getParts().add(part);
def.addNamespace(rqelem.getUri());
}
// generate output message information
Message rsmsg = new Message(odef.getResponseMessageName(), wns);
op.addOutputMessage(rsmsg);
def.addMessage(rsmsg);
ValueCustom rtrn = odef.getReturn();
QName rselem = null;
if (m_generationParameters.isDocLit()) {
// check if return value defined for method
if (!"void".equals(rtrn.getWorkingType())) {
// check for existing element definition matching the return type
rselem = (QName)classelems.get(rtrn.getWorkingType());
if (rselem == null) {
// create new element for return
ElementElement relem = buildValueElement(rtrn, ptypemap, typeschemas, holder);
schema.getTopLevelChildren().add(relem);
rselem = relem.getQName();
} else {
// import and use existing element definition
imports.add(elemschemas.get(rselem));
addSchemaReference(rqelem, elemschemas, holder);
}
}
} else {
// add corresponding schema definition to schema
SequenceElement seq = new SequenceElement();
if (!"void".equals(rtrn.getWorkingType())) {
ElementElement relem = buildValueElement(rtrn, ptypemap, typeschemas, holder);
seq.getParticleList().add(relem);
}
ComplexTypeElement tdef = new ComplexTypeElement();
tdef.setContentDefinition(seq);
ElementElement elem = new ElementElement();
String wname = odef.getResponseWrapperName();
elem.setName(wname);
elem.setTypeDefinition(tdef);
schema.getTopLevelChildren().add(elem);
rselem = new QName(sns, wname);
}
// add part definition to message (if present)
if (rselem != null) {
MessagePart part = new MessagePart("part", rselem);
rsmsg.getParts().add(part);
def.addNamespace(rselem.getUri());
}
// process fault message(s) for operation
ArrayList thrws = odef.getThrows();
WsdlCustom wsdlcustom = m_generationParameters.getWsdlCustom();
for (int j = 0; j < thrws.size(); j++) {
ThrowsCustom thrw = (ThrowsCustom)thrws.get(j);
String type = thrw.getType();
Message fmsg = (Message)fltmap.get(type);
if (fmsg == null) {
// first time for this throwable, create the message
FaultCustom fault = wsdlcustom.forceFaultCustomization(type);
QName fqname = new QName(sns, fault.getElementName());
MessagePart part = new MessagePart("fault", fqname);
fmsg = new Message(fault.getFaultName(), wns);
fmsg.getParts().add(part);
def.addMessage(fmsg);
def.addNamespace(sns);
// make sure the corresponding mapping exists
BindingMappingDetail detail = m_bindingGenerator.getMappingDetail(fault.getDataType());
if (detail == null) {
throw new IllegalStateException("No mapping found for type " + type);
}
// record that the fault has been defined
fltmap.put(type, fmsg);
}
// add fault to operation definition
op.addFaultMessage(fmsg);
}
// add operation to list of definitions
def.addOperation(op);
}
// include embedded schema for message definitions only if needed
if (holder.getReferences().size() > 0 || schema.getChildCount() > 0) {
def.getSchemas().add(schema);
}
return def;
}
/**
* Accumulate data type(s) from value to be included in binding.
*
* @param value
* @param clasmap map with classes to be excluded as keys
* @param dataset set of types for binding
*/
private void accumulateData(ValueCustom value, Map clasmap, Set dataset) {
String type = value.getBoundType();
if (!dataset.contains(type) && !clasmap.containsKey(type) && !Types.isSimpleValue(type)) {
String itype = value.getItemType();
if (itype == null) {
dataset.add(type);
} else {
dataset.add(itype);
}
}
}
/**
* Add the <mapping> definition for a typed collection to a binding. This always creates an abstract mapping with
* the type name based on both the item type and the collection type, except in the case where an array is being
* used in unwrapped (non-plain doc/lit) form.
*
* @param doclit plain doc/lit handling flag
* @param value collection value
* @param typemap map from parameterized type to abstract mapping name
* @param bind target binding
* @return qualified name for collection
*/
public QName addCollectionBinding(boolean doclit, ValueCustom value, Map typemap, BindingHolder bind) {
// check for existing mapping
String ptype = value.getBoundType();
QName qname = (QName)typemap.get(ptype);
if (qname == null) {
// check for either not an array, or plain doc/lit
String type = value.getWorkingType();
if (doclit || !type.endsWith("[]")) {
// create abstract mapping for collection class type
MappingElementBase mapping = new MappingElement();
mapping.setClassName(type);
mapping.setAbstract(true);
mapping.setCreateType(value.getCreateType());
mapping.setFactoryName(value.getFactoryMethod());
// generate the mapping type name from item class name and suffix
String suffix;
GlobalCustom global = m_generationParameters.getGlobal();
IClass clas = global.getClassInfo(type);
if (clas.isImplements("Ljava/util/List;")) {
suffix = "List";
} else if (clas.isImplements("Ljava/util/Set;")) {
suffix = "Set";
} else {
suffix = "Collection";
}
String itype = value.getItemType();
ClassCustom cust = global.addClassCustomization(itype);
// register the type name for mapping
String name = cust.getSimpleName() + suffix;
String uri = bind.getNamespace();
qname = new QName(uri, CustomBase.convertName(name, CustomBase.CAMEL_CASE_NAMES));
mapping.setTypeQName(qname);
bind.addTypeNameReference(uri, uri);
typemap.put(ptype, qname);
// add collection definition details
CollectionElement coll = new CollectionElement();
m_bindingGenerator.defineCollection(itype, value.getItemName(), coll, bind);
mapping.addChild(coll);
// add mapping to binding
bind.addMapping(mapping);
}
}
return qname;
}
/**
* Generate based on list of service classes.
*
* @param classes service class list
* @param extras list of extra classes for binding
* @param classelems fully-qualified class name to element qualified name map
* @param elemschemas element qualified name to schema element map
* @param classtypes fully-qualified class name to type qualified name map
* @param typeschemas type qualified name to schema element map
* @param exists existing schemas potentially referenced
* @return list of WSDLs
* @throws JiBXException
* @throws IOException
*/
private List generate(List classes, List extras, Map classelems, Map elemschemas, Map classtypes, Map typeschemas,
Collection exists) throws JiBXException, IOException {
// add any service classes not already present in customizations
WsdlCustom wsdlcustom = m_generationParameters.getWsdlCustom();
for (int i = 0; i < classes.size(); i++) {
String sclas = (String)classes.get(i);
if (wsdlcustom.getServiceCustomization(sclas) == null) {
wsdlcustom.addServiceCustomization(sclas);
}
}
// accumulate unmapped data classes used by all service operations
// TODO: throws class handling, with multiple services per WSDL
InsertionOrderedSet abstrs = new InsertionOrderedSet();
InsertionOrderedSet concrs = new InsertionOrderedSet();
ArrayList qnames = new ArrayList();
List services = wsdlcustom.getServices();
boolean doclit = m_generationParameters.isDocLit();
for (Iterator iter = services.iterator(); iter.hasNext();) {
ServiceCustom service = (ServiceCustom)iter.next();
List ops = service.getOperations();
for (Iterator iter1 = ops.iterator(); iter1.hasNext();) {
OperationCustom op = (OperationCustom)iter1.next();
List parms = op.getParameters();
if (doclit && parms.size() > 1) {
System.err.println("Multiple parmameters not allowed for doc/lit: method " + op.getMethodName());
}
for (Iterator iter2 = parms.iterator(); iter2.hasNext();) {
ValueCustom parm = (ValueCustom)iter2.next();
if (doclit) {
accumulateData(parm, classelems, concrs);
} else {
accumulateData(parm, classtypes, abstrs);
}
}
if (doclit) {
accumulateData(op.getReturn(), classelems, concrs);
} else {
accumulateData(op.getReturn(), classtypes, abstrs);
}
ArrayList thrws = op.getThrows();
for (int i = 0; i < thrws.size(); i++) {
// add concrete mapping for data type, if used
ThrowsCustom thrw = (ThrowsCustom)thrws.get(i);
FaultCustom fault = wsdlcustom.forceFaultCustomization(thrw.getType());
if (!concrs.contains(fault.getDataType())) {
concrs.add(fault.getDataType());
qnames.add(new QName(service.getNamespace(), fault.getElementName()));
}
}
}
}
// include extra classes as needing concrete mappings
GlobalCustom global = m_generationParameters.getGlobal();
for (int i = 0; i < extras.size(); i++) {
String type = (String)extras.get(i);
if (!concrs.contains(type)) {
concrs.add(type);
global.addClassCustomization(type);
qnames.add(null);
}
}
// generate bindings for all data classes used
m_bindingGenerator.generateSpecified(qnames, concrs.asList(), abstrs.asList());
// add binding definitions for collections passed or returned in plain doc/lit, and find empty service bindings
Map typemap = new HashMap();
Set unbounduris = new HashSet();
for (Iterator iter = services.iterator(); iter.hasNext();) {
ServiceCustom service = (ServiceCustom)iter.next();
List ops = service.getOperations();
String uri = service.getNamespace();
BindingHolder hold = m_bindingGenerator.addBinding(uri, false);
for (Iterator iter1 = ops.iterator(); iter1.hasNext();) {
OperationCustom op = (OperationCustom)iter1.next();
List parms = op.getParameters();
for (Iterator iter2 = parms.iterator(); iter2.hasNext();) {
ValueCustom parm = (ValueCustom)iter2.next();
if (parm.getItemType() != null) {
addCollectionBinding(doclit, parm, typemap, hold);
}
}
ValueCustom ret = op.getReturn();
if (ret.getItemType() != null) {
addCollectionBinding(doclit, ret, typemap, hold);
}
}
if (hold.getMappingCount() == 0) {
unbounduris.add(uri);
}
}
// ensure references for URIs with no mapping definitions
m_bindingGenerator.addRootUris(unbounduris);
// complete bindings and check if anything to be written
String name = m_generationParameters.getBindingName();
File path = m_generationParameters.getGeneratePath();
BindingHolder rhold = m_bindingGenerator.finish(name);
if (rhold.getBinding().topChildren().size() > 0) {
// write and validate the bindings
List bindings = m_bindingGenerator.validateFiles(path, m_generationParameters.getLocator(), rhold);
if (bindings == null) {
return null;
}
// build and record the schemas
List schemas = m_schemaGenerator.buildSchemas(bindings);
for (Iterator iter = schemas.iterator(); iter.hasNext();) {
SchemaHolder holder = (SchemaHolder)iter.next();
m_uriSchemaMap.put(holder.getNamespace(), holder);
}
}
// build the WSDL for each service
ArrayList wsdls = new ArrayList();
for (Iterator iter = services.iterator(); iter.hasNext();) {
wsdls.add(buildWSDL((ServiceCustom)iter.next(), typemap, classelems, elemschemas, classtypes, typeschemas));
}
m_schemaGenerator.finishSchemas(exists);
return wsdls;
}
/**
* Accumulate all mapping definitions, including those found in included bindings. For each named abstract mapping
* found, the class name is associated with the type name in the type map; for each concrete mapping found, the
* class name is associated with the element name in the element map. Included bindings are handled with recursive
* calls.
*
* @param binding binding definition root
* @param elemmap map from fully-qualified class name to element qualified name
* @param typemap map from fully-qualified class name to type qualified name
*/
private static void accumulateBindingDefinitions(BindingElement binding, Map elemmap, Map typemap) {
ArrayList childs = binding.topChildren();
for (int i = 0; i < childs.size(); i++) {
ElementBase element = (ElementBase)childs.get(i);
if (element.type() == ElementBase.INCLUDE_ELEMENT) {
// use recursive call to add nested definitions in included binding
accumulateBindingDefinitions(((org.jibx.binding.model.IncludeElement)element).getBinding(), elemmap,
typemap);
} else if (element.type() == ElementBase.MAPPING_ELEMENT) {
// handle mapping as type if abstract with type name, or as element if concrete
MappingElementBase mapping = (MappingElementBase)element;
String cname = mapping.getClassName();
if (mapping.isAbstract()) {
QName qname = mapping.getTypeQName();
if (qname != null) {
typemap.put(cname, qname);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Added class " + cname + " with type " + qname);
}
}
} else {
QName qname = new QName(mapping.getNamespace().getUri(), mapping.getName());
elemmap.put(cname, qname);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Added class " + cname + " with element " + qname);
}
}
}
}
}
/**
* Load and validate binding and process all mapping definitions, including those in included bindings.
*
* @param url binding definition path
* @param elemmap map from element qualified name to class data
* @param typemap map from type qualified name to class data
* @return binding
* @throws JiBXException
* @throws IOException
*/
public static BindingElement processPregeneratedBinding(URL url, Map elemmap, Map typemap)
throws JiBXException, IOException {
// get binding definition file name from path
String name = "";
String path = url.getPath();
if (path != null) {
name = path;
int split = Math.max(name.lastIndexOf('/'), name.lastIndexOf('\\'));
if (split > 0) {
name = name.substring(split+1);
}
split = name.lastIndexOf('.');
name = name.substring(0, split);
}
// construct object model for binding
org.jibx.binding.model.ValidationContext vctx =
new org.jibx.binding.model.ValidationContext(new DummyClassLocator());
BindingElement binding = BindingElement.readBinding(url.openStream(), name, null, true,
vctx);
binding.setBaseUrl(url);
vctx.setBindingRoot(binding);
// validate the binding definition
binding.runValidation(vctx);
// list validation errors
ArrayList probs = vctx.getProblems();
if (probs.size() > 0) {
for (int i = 0; i < probs.size(); i++) {
org.jibx.binding.model.ValidationProblem prob =
(org.jibx.binding.model.ValidationProblem)probs.get(i);
System.out.print(prob.getSeverity() >=
ValidationProblem.ERROR_LEVEL ? "Error: " : "Warning: ");
System.out.println(prob.getDescription());
}
if (vctx.getErrorCount() > 0 || vctx.getFatalCount() > 0) {
throw new JiBXException("Errors in binding");
}
}
// add all the mapping and format definitions in binding to qualified name maps
accumulateBindingDefinitions(binding, elemmap, typemap);
return binding;
}
/**
* Run the WSDL generation using command line parameters.
*
* @param args
* @throws JiBXException
* @throws IOException
*/
public static void main(String[] args) throws JiBXException, IOException {
WsdlGeneratorCommandLine parms = new WsdlGeneratorCommandLine();
if (args.length > 0 && parms.processArgs(args)) {
// build set of schemas provided on command line
final Set resolves = new HashSet();
List errors = ResourceMatcher.matchPaths(new File("."), null, parms.getUseSchemas(),
new ResourceMatcher.ReportMatch() {
public void foundMatch(String path, URL url) {
resolves.add(new UrlResolver(path, url));
}
});
if (errors.size() > 0) {
for (Iterator iter = errors.iterator(); iter.hasNext();) {
System.err.println(iter.next());
}
System.exit(1);
}
// load and validate schemas
ValidationContext vctx = new ValidationContext();
ValidationUtils.load(resolves, null, vctx);
ProblemMultiHandler handler = new ProblemMultiHandler();
handler.addHandler(new ProblemConsoleLister());
handler.addHandler(new ProblemLogLister(s_logger));
if (vctx.reportProblems(handler)) {
System.exit(2);
}
// build maps from qualified names to schema holders, and from schema to resolver (necessary since a new
// resolver will be set during the WSDL generation processing)
final Map elemschemas = new HashMap();
final Map typeschemas = new HashMap();
final Set exists = new HashSet();
TreeWalker wlkr = new TreeWalker(null, new SchemaContextTracker());
for (Iterator iter = resolves.iterator(); iter.hasNext();) {
SchemaElement schema = vctx.getSchemaById(((ISchemaResolver)iter.next()).getId());
exists.add(schema);
final SchemaHolder holder = new SchemaHolder(schema);
SchemaVisitor visitor = new SchemaVisitor() {
public boolean visit(SchemaBase node) {
return false;
}
public boolean visit(ComplexTypeElement node) {
typeschemas.put(node.getQName(), holder);
return false;
}
public boolean visit(ElementElement node) {
elemschemas.put(node.getQName(), holder);
return false;
}
};
wlkr.walkChildren(schema, visitor);
}
// build set of binding definitions provided on command line
final Set bindings = new HashSet();
errors = ResourceMatcher.matchPaths(new File("."), null, parms.getUseBindings(),
new ResourceMatcher.ReportMatch() {
public void foundMatch(String path, URL url) {
bindings.add(url);
}
});
if (errors.size() > 0) {
for (Iterator iter = errors.iterator(); iter.hasNext();) {
System.err.println(iter.next());
}
System.exit(3);
}
// build maps of type and element mappings from bindings
Map classelems = new HashMap();
Map classtypes = new HashMap();
for (Iterator iter = bindings.iterator(); iter.hasNext();) {
URL url = (URL)iter.next();
processPregeneratedBinding(url, classelems, classtypes);
}
// generate services, bindings, and WSDLs
Jibx2Wsdl inst = new Jibx2Wsdl(parms);
ArrayList extras = new ArrayList(parms.getExtraTypes());
ArrayList classes = parms.getGlobal().getUnmarshalledClasses();
for (int i = 0; i < classes.size(); i++) {
ClassCustom clas = (ClassCustom)classes.get(i);
if (clas.isForceMapping()) {
extras.add(clas.getName());
}
}
List wsdls = inst.generate(parms.getExtraArgs(), extras, classelems, elemschemas, classtypes, typeschemas,
exists);
if (wsdls != null) {
// write the schemas and WSDLS
SchemaGen.writeSchemas(parms.getGeneratePath(), inst.m_uriSchemaMap.values());
WsdlWriter writer = new WsdlWriter();
for (Iterator iter = wsdls.iterator(); iter.hasNext();) {
Definitions def = (Definitions)iter.next();
File file = new File(parms.getGeneratePath(), def.getServiceName() + ".wsdl");
writer.writeWSDL(def, new FileOutputStream(file));
}
// find existing schemas referenced (directly or indirectly) from WSDL schemas
final Set needschemas = new HashSet();
SchemaVisitor visitor = new SchemaVisitor() {
private int m_existsDepth;
public void exit(SchemaElement node) {
if (exists.contains(node)) {
m_existsDepth--;
}
}
public boolean visit(SchemaBase node) {
return false;
}
public boolean visit(SchemaElement node) {
if (exists.contains(node)) {
m_existsDepth++;
}
return true;
}
public boolean visit(SchemaLocationBase node) {
SchemaElement schema = node.getReferencedSchema();
if (needschemas.contains(schema)) {
return false;
} else {
if (m_existsDepth > 0 || exists.contains(schema)) {
needschemas.add(schema);
}
return true;
}
}
};
for (int i = 0; i < wsdls.size(); i++) {
Definitions def = (Definitions)wsdls.get(i);
ArrayList schemas = def.getSchemas();
for (int j = 0; j < schemas.size(); j++) {
wlkr.walkChildren((SchemaBase)schemas.get(0), visitor);
}
}
// copy all referenced schemas to target directory
byte[] buff = new byte[4096];
for (Iterator iter = needschemas.iterator(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
UrlResolver resolver = (UrlResolver)schema.getResolver();
InputStream is = resolver.getUrl().openStream();
File file = new File(parms.getGeneratePath(), resolver.getName());
FileOutputStream os = new FileOutputStream(file);
int actual;
while ((actual = is.read(buff)) > 0) {
os.write(buff, 0, actual);
}
schema.setResolver(new MemoryResolver(resolver.getName()));
}
}
} else {
if (args.length > 0) {
System.err.println("Terminating due to command line errors");
} else {
parms.printUsage();
}
System.exit(1);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/ 0000755 0001750 0001750 00000000000 11526304014 021255 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/binding/ant/ 0000755 0001750 0001750 00000000000 11526304016 022041 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/binding/ant/CompileTask.java 0000644 0001750 0001750 00000025177 10221057702 025131 0 ustar twerner twerner /*
Copyright (c) 2003, Andrew J. Glover
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.ant;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import org.apache.tools.ant.AntClassLoader;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.DirectoryScanner;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.types.FileSet;
import org.apache.tools.ant.types.Path;
import org.jibx.binding.Compile;
import org.jibx.runtime.JiBXException;
/**
* Class alters user defined class files for JiBX functionality.
* @author aglover
* @author pledbrook
*/
public class CompileTask extends Task {
private boolean m_load;
private boolean m_verbose;
private Path m_classpath;
private List m_fileSet;
private List m_bindingFileSet;
private String m_bindingFile;
/**
* Hook method called by ant framework to handle
* task initialization.
*
*/
public void init() throws BuildException {
//
// Do aprent initialisation first.
//
super.init();
//
// Now create the lists that store the classpathsets and
// the bindingsets.
//
m_fileSet = new ArrayList();
m_bindingFileSet = new ArrayList();
}
/**
* Returns an array of paths of all the files specified by the
* or tags. Note that the
* and tags cannot both be specified.
*/
private String[] getPaths() {
String[] pathArray = null;
if (m_classpath != null) {
//
// If a tag has been set, m_classpath will
// not be null. In this case, just return the array of
// paths directly.
//
pathArray = m_classpath.list();
} else {
//
// Store the directory paths specified by each of the
// tags.
//
pathArray = new String[m_fileSet.size()];
for(int i = 0; i < m_fileSet.size(); i++) {
FileSet fileSet = (FileSet)m_fileSet.get(i);
File directory = fileSet.getDir(project);
pathArray[i] = directory.getAbsolutePath();
}
}
// make Ant classpath usable by application
try {
System.setProperty("java.class.path",
((AntClassLoader)CompileTask.class.getClassLoader()).getClasspath());
} catch (Exception e) {
System.err.println("Failed setting classpath from Ant task");
}
//
// If verbose mode is on, print out the paths we are using.
//
if (m_verbose) {
log("Using the following paths:");
for (int i = 0; i < pathArray.length; i++) {
log(" " + pathArray[i]);
}
}
return pathArray;
}
/**
* Returns an array of all the paths specified by the "binding"
* attribute or the tags.
*/
private String[] getBindings() {
String[] bindings = null;
if (m_bindingFileSet.size() == 0) {
//
// No tags have been specified, so use
// the task's "binding" attribute instead.
//
bindings = new String[] { m_bindingFile };
} else {
//
// For each fileset, get all the file paths included by it.
//
ArrayList paths = new ArrayList();
for(int i = 0; i < m_bindingFileSet.size(); i++){
FileSet bPath = (FileSet)m_bindingFileSet.get(i);
DirectoryScanner dirScn = bPath.getDirectoryScanner(project);
String[] bndingFiles = dirScn.getIncludedFiles();
for(int x = 0; x < bndingFiles.length; x++){
String fullPath = dirScn.getBasedir()
+ System.getProperty("file.separator")
+ bndingFiles[x];
paths.add(fullPath);
}
}
//
// Convert the ArrayList of binding files into a native array.
//
bindings = (String[])paths.toArray(new String[paths.size()]);
}
//
// If verbose mode is on, print out the binding files
// we are using.
//
if (m_verbose) {
log("Using the following binding paths:");
for (int i = 0; i < bindings.length; i++) {
log(" " + bindings[i]);
}
}
return bindings;
}
/**
* This checks that the build file has specified the correct
* mix of <classpath>, <classpathset>, <bindingfileset>
* and "binding". The rules are as follows:
*
* - Either the "binding" attribute or <bindingfileset>
* tags must be set. Not both.
* - Either a single <classpath> tag or multiple
* <classpathset> tags must be set. Not both.
*
* @throws BuildException
*/
private void validateRequiredFields() throws BuildException {
//
// Check at least one of the binding file properties is set.
//
if (m_bindingFileSet.isEmpty() && m_bindingFile == null) {
throw new BuildException("Either the binding attribute or at "
+ "least one bindingset nested element "
+ "must be defined.");
}
//
// Make sure that the "binding" attribute has not been used with the
// nested element.
//
if (!m_bindingFileSet.isEmpty() && m_bindingFile != null) {
throw new BuildException("You cannot specify both a binding attribute and a "
+ "bindingset nested element.");
}
//
// Check either or has been set.
//
if(m_classpath == null && m_fileSet.isEmpty()) {
throw new BuildException("You must specify either a classpath "
+ "or at least one nested classpathset element.");
}
//
// Make sure that only one of the above is specified.
//
if (m_classpath != null && !m_fileSet.isEmpty()) {
throw new BuildException("You cannot specify both a classpath and a "
+ "classpathset nested element.");
}
}
/**
*
* Hook method called by Ant. Method first determines
* class file path from user defined value, then
* determines all binding files for class file weaving.
*
*/
public void execute() throws BuildException{
try{
validateRequiredFields();
String[] pathArr = getPaths();
String[] bindings = getBindings();
Compile compiler = new Compile();
//right now there is an issue with dynamically loading
//class files with ant. it doesnt work unless the class
//files are part of ANT's classpath. so I am forcing this
//to always be false until we can come up with a better solution.
compiler.setLoad(m_load);
compiler.setVerbose(m_verbose);
compiler.compile(pathArr, bindings);
} catch(JiBXException jEx) {
jEx.printStackTrace();
throw new BuildException("JiBXException in JiBX binding compilation", jEx);
}
}
/**
*
* @param fSet
*/
public void addClassPathSet(FileSet fSet){
m_fileSet.add(fSet);
}
/**
* Returns the current classpath.
*/
public Path getClasspath() {
return m_classpath;
}
/**
* Sets the classpath for this task. Multiple calls append the
* new classpath to the current one, rather than overwriting it.
* @param classpath The new classpath as a Path object.
*/
public void setClasspath(Path classpath) {
if (m_classpath == null) {
m_classpath = classpath;
}
else {
m_classpath.append(classpath);
}
}
/**
* Creates the classpath for this task and returns
* it. If the classpath has already been created,
* the method just returns that one.
*/
public Path createClasspath() {
if (m_classpath == null) {
m_classpath = new Path(project);
}
return m_classpath;
}
/**
* @param file
*/
public void setBinding(String file) {
m_bindingFile = file;
}
/**
*
* @param bfSet
*/
public void addBindingFileSet(FileSet bfSet) {
m_bindingFileSet.add(bfSet);
}
/**
* @param bool
*/
public void setLoad(boolean bool) {
m_load = bool;
}
/**
* @param bool
*/
public void setVerbose(boolean bool) {
m_verbose = bool;
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/binding/Utility.java 0000644 0001750 0001750 00000040502 11475012262 023570 0 ustar twerner twerner /*
Copyright (c) 2003-2010, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.jar.Attributes;
import java.util.jar.JarFile;
import java.util.jar.Manifest;
import org.jibx.binding.classes.BoundClass;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.def.BindingBuilder;
import org.jibx.binding.def.BindingDefinition;
import org.jibx.binding.def.MappingBase;
import org.jibx.binding.model.BindingElement;
import org.jibx.binding.model.IncludeElement;
import org.jibx.binding.model.MappingElement;
import org.jibx.binding.model.MappingElementBase;
import org.jibx.binding.model.ValidationContext;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.UnmarshallingContext;
/**
* Binding compiler support class. Supplies common methods for use in compiling
* binding definitions.
*
* @author Dennis M. Sosnoski
*/
public class Utility
{
// buffer size for copying stream input
private static final int COPY_BUFFER_SIZE = 1024;
// private constructor to prevent any instance creation
private Utility() {}
/**
* Read contents of stream into byte array.
*
* @param is input stream to be read
* @return array of bytes containing all data from stream
* @throws IOException on stream access error
*/
private static byte[] getStreamData(InputStream is) throws IOException {
byte[] buff = new byte[COPY_BUFFER_SIZE];
ByteArrayOutputStream os = new ByteArrayOutputStream();
int count;
while ((count = is.read(buff)) >= 0) {
os.write(buff, 0, count);
}
return os.toByteArray();
}
/**
* Recurse through jar file path component, adding all jars referenced from
* the original jar to the path collection. Silently ignores problems
* loading jar files.
*
* @param path jar path component
* @param paths set of paths processed (added to by call)
*/
private static void recursePathJars(String path, ArrayList paths) {
try {
// check class path information in jar file
JarFile jfile = new JarFile(path, false);
Manifest mfst = jfile.getManifest();
if (mfst != null) {
// look for class path information from manifest
Attributes attrs = mfst.getMainAttributes();
String cpath = (String)attrs.get(Attributes.Name.CLASS_PATH);
if (cpath != null) {
// set base path for all relative references
if (File.separatorChar != '/') {
path = path.replace('/', File.separatorChar);
}
int split = path.lastIndexOf(File.separatorChar);
String base = (split >= 0) ?
path.substring(0, split+1) : "";
// process all references in jar class path
while (cpath != null) {
split = cpath.indexOf(' ');
String item;
if (split >= 0) {
item = cpath.substring(0, split);
cpath = cpath.substring(split+1).trim();
} else {
item = cpath;
cpath = null;
}
String ipath = base + item;
if (!paths.contains(ipath)) {
paths.add(ipath);
split = ipath.lastIndexOf('.');
if (split >= 0 && "jar".equalsIgnoreCase
(ipath.substring(split+1))) {
recursePathJars(ipath, paths);
}
}
}
}
}
} catch (IOException ex) { /* silently ignore problems in loading */ }
}
/**
* Method builds a string array of items in the class path.
*
* @return array of classpath components
*/
public static String[] getClassPaths() {
// get all class path components
String path = System.getProperty("java.class.path");
ArrayList paths = new ArrayList();
int start = 0;
int mark;
while (path != null) {
mark = path.indexOf(File.pathSeparatorChar, start);
String item;
if (mark >= 0) {
item = path.substring(start, mark);
} else {
item = path.substring(start);
path = null;
}
if (!paths.contains(item)) {
paths.add(item);
int split = item.lastIndexOf('.');
if (split >= 0 &&
"jar".equalsIgnoreCase(item.substring(split+1))) {
recursePathJars(item, paths);
}
}
start = mark + 1;
}
paths.add(".");
String[] clsspths = new String[paths.size()];
paths.toArray(clsspths);
return clsspths;
}
/**
* Extract base file name from a full path.
*
* @param path full file path
* @return file name component from path
*/
public static String fileName(String path) {
if (File.separatorChar != '/') {
path = path.replace('/', File.separatorChar);
}
int split = path.lastIndexOf(File.separatorChar);
return path.substring(split+1);
}
/**
* Get the default binding name from a supplied file name.
*
* @param fname simple file name (without leading path information)
* @return default binding name
*/
public static String bindingFromFileName(String fname) {
String sname = fname;
int split = sname.indexOf('.');
if (split > 0) {
sname = sname.substring(0, split);
}
return BindingDirectory.convertName(sname);
}
/**
* Validate binding definition. If issues are found in the binding the
* issues are printed directly to the console.
*
* @param name identifier for binding definition
* @param url URL for binding definition (null if not
* available)
* @param is input stream for reading binding definition
* @return root element of binding model if binding is valid,
* null if one or more errors in binding
*/
public static BindingElement validateBinding(String name, URL url,
InputStream is) {
try {
ValidationContext vctx = BindingElement.newValidationContext();
BindingElement root =
BindingElement.validateBinding(name, url, is, vctx);
if (vctx.getErrorCount() == 0 && vctx.getFatalCount() == 0) {
return root;
}
} catch (JiBXException ex) {
System.err.println("Unable to process binding " + name);
ex.printStackTrace();
}
return null;
}
/**
* Load validated binding definition. This first reads the input stream into
* a memory buffer, then parses the data once for validation and a second
* time for the actual binding definition construction. If any errors are
* found in the binding definition validation the construction is skipped
* and an exception is thrown.
*
* @param fname binding definition full name
* @param sname short form of name to use as the default name of the binding
* @param istrm input stream for binding definition document
* @param url URL for binding definition (null if not
* available)
* @param test validate binding flag
* @return constructed binding definition
* @exception FileNotFoundException if path cannot be accessed
* @exception JiBXException if error in processing the binding definition
* @throws IOException if error reading the binding
*/
public static BindingDefinition loadBinding(String fname, String sname,
InputStream istrm, URL url, boolean test)
throws JiBXException, IOException {
// read stream into memory buffer
byte[] data = getStreamData(istrm);
// validate using binding object model
boolean valid = true;
ClassFile cf = null;
String tpack = null;
String bname = null;
if (test) {
BindingElement root = validateBinding(fname, url,
new ByteArrayInputStream(data));
if (root == null) {
valid = false;
} else {
// find package of first mapping to use for added classes
cf = findMappedClass(root);
tpack = root.getTargetPackage();
if (tpack == null && cf != null) {
tpack = cf.getPackage();
}
bname = root.getName();
}
}
if (valid) {
try {
// construct the binding definition code generator
UnmarshallingContext uctx = new UnmarshallingContext();
uctx.setDocument(new ByteArrayInputStream(data), fname, null);
if (cf != null) {
// set target root and package for created classes
if (bname == null) {
bname = sname;
}
BoundClass.setModify(cf.getRoot(), tpack, bname);
}
BindingDefinition bdef =
BindingBuilder.unmarshalBindingDefinition(uctx, sname, url);
// set package and class if not validated
if (!test) {
// a kludge, but needed to support skipping validation
ArrayList maps = bdef.getDefinitionContext().getMappings();
if (maps != null) {
// set up package information from mapped class
for (int i = 0; i < maps.size(); i++) {
Object child = maps.get(i);
if (child instanceof MappingBase) {
// end scan if a real mapping is found
MappingBase mapbase = (MappingBase)child;
cf = mapbase.getBoundClass().getMungedFile();
if (mapbase.getBoundClass().isDirectAccess()) {
break;
}
}
}
}
}
// set up binding root based on first mapping
File root = null;
if (tpack == null) {
tpack = bdef.getDefaultPackage();
}
if (cf == null) {
root = ClassCache.getModifiablePath();
if (root == null) {
throw new IllegalStateException("Need modifiable directory on classpath for storing generated factory class file");
}
if (tpack == null) {
tpack = "";
}
} else {
root = cf.getRoot();
if (tpack == null) {
tpack = cf.getPackage();
}
}
bdef.setFactoryLocation(tpack, root);
return bdef;
} catch (JiBXException e) {
throw new JiBXException
("\n*** Error during code generation for file '" + fname +
"' - please enter a bug report for this error in Jira if " +
"the problem is not listed as fixed on the online status " +
"page ***\n", e);
}
} else {
throw new JiBXException("Binding " + fname +
" is unusable because of validation errors");
}
}
/**
* Recursively search through binding definitions for a modifiable mapped
* class. This is used to determine the default package for code generation.
*
* @param root binding element at root of definition
* @return modifiable mapped class, or null if none
*/
private static ClassFile findMappedClass(BindingElement root) {
ArrayList childs = root.topChildren();
if (childs != null) {
// recursively search for modifiable mapped class
for (int i = childs.size() - 1; i >= 0 ; i--) {
Object child = childs.get(i);
if (child instanceof MappingElement) {
// end scan if a real mapping is found
MappingElementBase map = (MappingElementBase)child;
ClassFile cf = map.getHandledClass().getClassFile();
if (!cf.isInterface() && cf.isModifiable()) {
return cf;
}
} else if (child instanceof IncludeElement) {
// recurse on included binding
BindingElement bind = ((IncludeElement)child).getBinding();
if (bind != null) {
ClassFile cf = findMappedClass(bind);
if (cf != null) {
return cf;
}
}
}
}
}
return null;
}
/**
* Load binding definition from file.
*
* @param path file path for binding definition
* @param valid validate binding flag
* @return constructed binding definition
* @exception IOException if error accessing file
* @exception JiBXException if error in processing the binding definition
*/
public static BindingDefinition loadFileBinding(String path, boolean valid)
throws JiBXException, IOException {
// extract basic name of binding file from path
File file = new File(path);
String fname = fileName(file.getAbsolutePath());
String sname = bindingFromFileName(fname);
// construct and return the binding definition
return loadBinding(fname, sname, new FileInputStream(file),
file.toURI().toURL(), valid);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/Compile.java 0000644 0001750 0001750 00000041047 11321161756 023525 0 ustar twerner twerner /*
Copyright (c) 2003-2010, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import org.apache.bcel.classfile.Method;
import org.apache.bcel.verifier.VerificationResult;
import org.apache.bcel.verifier.Verifier;
import org.apache.bcel.verifier.VerifierFactory;
import org.jibx.binding.classes.BoundClass;
import org.jibx.binding.classes.BranchWrapper;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.MungedClass;
import org.jibx.binding.def.BindingDefinition;
import org.jibx.runtime.JiBXException;
import org.jibx.util.ClasspathUrlExtender;
/**
* Binding compiler. This version checks the modified and generated classes
* by loading them and listing method information.
*
* @author Dennis M. Sosnoski
*/
public class Compile
{
private boolean m_verbose1;
private boolean m_verbose2;
private boolean m_load;
private boolean m_verify;
private boolean m_trackBranches;
private boolean m_errorOverride;
private boolean m_skipValidate;
/**
* Default constructor. This just initializes all options disabled.
*/
public Compile() {}
/**
* Constructor with settings specified.
*
* @param verbose1 report binding details and results
* @param verbose2 report second pass binding details
* @param load test load modified classes to validate
* @param verify use BCEL validation of modified classes
* @param track keep tracking information for source of branch generation
* @param over override code generation error handling
*/
public Compile(boolean verbose1, boolean verbose2, boolean load,
boolean verify, boolean track, boolean over) {
m_verbose1 = verbose1;
m_verbose2 = verbose2;
m_load = load;
m_verify = verify;
m_trackBranches = track;
m_errorOverride = over;
}
/**
* Verify generated and modified files using BCEL verifier. This provides a
* more comprehensive listing of errors than just loading a class in the
* JVM.
*
* @param file information for class to be verified
* @return true if successfully verified, false if
* problem found (automatically reported)
*/
private boolean verifyBCEL(ClassFile file) {
try {
// construct verifier for class file
Verifier verifier = VerifierFactory.getVerifier(file.getName());
// run validation in stages with error handling for each stage
boolean verified = false;
VerificationResult vr = verifier.doPass1();
if (vr.getStatus() == VerificationResult.VERIFIED_OK) {
vr = verifier.doPass2();
if (vr.getStatus() == VerificationResult.VERIFIED_OK) {
Method[] methods = file.getRawClass().getMethods();
for (int j = 0; j < methods.length; j++) {
vr = verifier.doPass3a(j);
if (vr.getStatus() == VerificationResult.VERIFIED_OK) {
vr = verifier.doPass3b(j);
}
if (vr.getStatus() == VerificationResult.VERIFIED_OK) {
verified = true;
} else {
System.out.println
("Verification failure on method " +
methods[j].getName() + " of class " +
file.getName() + ":");
System.out.println(" " + vr.toString());
}
}
} else {
System.out.println("Verification failure on class " +
file.getName() + ":");
System.out.println(" " + vr.toString());
}
} else {
System.out.println("Verification failure on class " +
file.getName() + ":");
System.out.println(" " + vr.toString());
}
return verified;
} catch (Exception ex) { // catch BCEL errors
System.out.println("BCEL failure:");
ex.printStackTrace();
return false;
}
}
/**
* Set control flag for test loading generated/modified classes.
*
* @param load test load generated/modified classes flag
*/
public void setLoad(boolean load) {
m_load = load;
}
/**
* Set control flag for verbose processing reports.
*
* @param verbose report verbose information in processing bindings flag
*/
public void setVerbose(boolean verbose) {
m_verbose1 = verbose;
}
/**
* Set control flag for verifying generated/modified classes with BCEL.
*
* @param verify use BCEL verification for generated/modified classes flag
*/
public void setVerify(boolean verify) {
m_verify = verify;
}
/**
* Set control flag for skipping binding validation. This flag is intended
* only for use while processing the binding model components within JiBX.
* Otherwise it'd be impossible to correct errors in the binding validation.
*
* @param skip test load generated/modified classes flag
*/
public void setSkipValidate(boolean skip) {
m_skipValidate = skip;
}
/**
* Compile a set of bindings using supplied classpaths.
*
* @param paths list of paths for loading classes
* @param files list of binding definition files
* @exception JiBXException if error in processing the binding definition
*/
public void compile(String[] paths, String[] files) throws JiBXException {
try {
// include current version information in verbose output
if (m_verbose1) {
System.out.println("Running binding compiler version " +
BindingDefinition.CURRENT_VERSION_NAME);
}
// set paths to be used for loading referenced classes
ClassCache.setPaths(paths);
ClassFile.setPaths(paths);
ClasspathUrlExtender.setClassLoader(ClassFile.getClassLoader());
// reset static information accumulation for binding
BoundClass.reset();
MungedClass.reset();
BindingDefinition.reset();
BranchWrapper.setTracking(m_trackBranches);
BranchWrapper.setErrorOverride(m_errorOverride);
// load all supplied bindings
BindingDefinition[] defs = new BindingDefinition[files.length];
for (int i = 0; i < files.length; i++) {
defs[i] = Utility.loadFileBinding(files[i], !m_skipValidate);
if (m_verbose1) {
defs[i].print();
}
}
// modify the class files with JiBX hooks
for (int i = 0; i < defs.length; i++) {
try {
defs[i].generateCode(m_verbose1, m_verbose2);
} catch (RuntimeException e) {
throw new JiBXException
("\n*** Error during code generation for file '" +
files[i] + "' -\n this may be due to an error in " +
"your binding or classpath, or to an error in the " +
"JiBX code ***\n", e);
}
}
// get the lists of class names modified, kept unchanged, and unused
ClassFile[][] lists = MungedClass.fixDispositions();
// add class used list to each binding factory and output files
for (int i = 0; i < defs.length; i++) {
defs[i].addClassList(lists[0], lists[1]);
}
MungedClass.writeChanges();
// report modified file results to user
ClassFile[] adds = lists[0];
int addcount = adds.length;
if (m_verbose1) {
System.out.println("\nWrote " + addcount + " files");
}
if (m_verbose1 || m_load) {
// generate class paths as URLs if needed for test loading
URL[] urls = null;
if (m_load) {
urls = new URL[paths.length];
for (int i = 0; i < urls.length; i++) {
urls[i] = new File(paths[i]).toURI().toURL();
}
}
for (int i = 0; i < addcount; i++) {
// write class file to bytes
ClassFile file = adds[i];
ByteArrayOutputStream bos = new ByteArrayOutputStream();
file.writeFile(bos);
byte[] bytes = bos.toByteArray();
if(m_verbose1){
System.out.println("\n " + file.getName() +
" output file size is " + bytes.length + " bytes");
}
// verify using BCEL verifier
if (m_verify) {
verifyBCEL(file);
}
// load to JVM and list method information from class
if (m_load) {
DirectLoader cloader = new DirectLoader(urls);
Class clas = cloader.load(file.getName(), bytes);
if (m_verbose1) {
java.lang.reflect.Method[] methods =
clas.getDeclaredMethods();
System.out.println(" Found " + methods.length +
" methods:");
for (int j = 0; j < methods.length; j++) {
java.lang.reflect.Method method = methods[j];
System.out.println(" " +
method.getReturnType().getName() + " " +
method.getName());
}
}
}
}
}
// report summary information for files unchanged or deleted
if (m_verbose1) {
ClassFile[] keeps = lists[1];
System.out.println("\nKept " + keeps.length + " files unchanged:");
for (int i = 0; i < keeps.length; i++) {
System.out.println(" " + keeps[i].getName());
}
ClassFile[] dels = lists[2];
System.out.println("\nDeleted " + dels.length + " files:");
for (int i = 0; i < dels.length; i++) {
System.out.println(" " + dels[i].getName());
}
}
} catch (IOException ex) {
throw new JiBXException("IOException in compile", ex);
} catch (ExceptionInInitializerError ex) {
throw new JiBXException("Error during initialization;" +
" is jibx-run.jar in load classpath?", ex.getException());
} catch (Throwable ex) {
throw new JiBXException("Error running binding compiler", ex);
}
}
/**
* Main method for running compiler as application.
*
* @param args command line arguments
*/
public static void main(String[] args) {
if (args.length > 0) {
try {
// check for various flags set
boolean verbose1 = false;
boolean verbose2 = false;
boolean load = false;
boolean verify = false;
boolean track = false;
boolean over = false;
boolean skip = false;
int offset = 0;
for (; offset < 5 && offset < args.length; offset++) {
String arg = args[offset];
if ("-v".equalsIgnoreCase(arg)) {
if (verbose1) {
verbose2 = true;
} else {
verbose1 = true;
}
} else if ("-l".equalsIgnoreCase(arg)) {
load = true;
} else if ("-b".equalsIgnoreCase(arg)) {
verify = true;
} else if ("-o".equalsIgnoreCase(arg)) {
over = true;
} else if ("-s".equalsIgnoreCase(arg)) {
skip = true;
} else if ("-t".equalsIgnoreCase(arg)) {
track = true;
} else {
break;
}
}
// set up path and binding lists
String[] clsspths = Utility.getClassPaths();
String[] bindings = new String[args.length - offset];
System.arraycopy(args, offset, bindings, 0, bindings.length);
// report on the configuration
if (verbose1) {
System.out.println("Using paths:");
for (int i = 0; i < clsspths.length; i++) {
System.out.println(" " + clsspths[i]);
}
System.out.println("Using bindings:");
for (int i = 0; i < bindings.length; i++) {
System.out.println(" " + bindings[i]);
}
}
// compile the bindings
Compile compiler =
new Compile(verbose1, verbose2, load, verify, track, over);
compiler.setSkipValidate(skip);
compiler.compile(clsspths, bindings);
} catch (JiBXException ex) {
ex.printStackTrace(System.out);
System.exit(1);
}
} else {
System.out.println
("\nUsage: java org.jibx.binding.Compile [-b] [-l] [-v] " +
"binding1 binding2 ...\nwhere:\n -b turns on BCEL " +
"verification (debug option),\n -l turns on test loading of " +
"modified or generated classes for validation, and\n" +
" -v turns on verbose output\nThe bindingn files are " +
"different bindings to be compiled.\n");
System.exit(1);
}
}
/**
* Direct class loader. This is optionally used for test loading the
* modified class files to make sure they're still valid.
*/
private static class DirectLoader extends URLClassLoader
{
protected DirectLoader(URL[] urls) {
super(urls, DirectLoader.class.getClassLoader());
}
protected Class load(String name, byte[] data) {
return defineClass(name, data, 0, data.length);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/ 0000755 0001750 0001750 00000000000 11526304014 022355 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/NameAttributes.java 0000644 0001750 0001750 00000014141 11524071762 026161 0 ustar twerner twerner /*
Copyright (c) 2004-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import org.jibx.runtime.Utility;
import org.jibx.util.StringArray;
/**
* Model component for name attribute group in binding definition.
*
* @author Dennis M. Sosnoski
*/
public class NameAttributes extends AttributeBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "name", "ns" });
// TODO: add "prefix" to set for 2.0
/** Name text. */
private String m_name;
/** Namespace URI. */
private String m_uri;
/** Namespace prefix. */
private String m_prefix;
/** Name represents an attribute flag. */
private boolean m_isAttribute;
/** Namespace definition used by this name. */
private NamespaceElement m_namespace;
/**
* Default constructor.
*/
public NameAttributes() {}
/**
* Set flag for an attribute name. This information is necessary for
* resolving the namespace definition to be used with a name, but has to be
* determined by the element owning this attribute group. It must be set (if
* different from the default of false) prior to validation.
*
* @param isattr flag for name represents an attribute
*/
public void setIsAttribute(boolean isattr) {
m_isAttribute = isattr;
}
/**
* Get flag for an attribute name.
*
* @return true if an attribute, false if an
* element
*/
public boolean isAttribute() {
return m_isAttribute;
}
/**
* Get name.
*
* @return name text
*/
public String getName() {
return m_name;
}
/**
* Set name.
*
* @param name text for name
*/
public void setName(String name) {
m_name = name;
}
/**
* Get specified namespace URI.
*
* @return namespace URI (null if not set)
*/
public String getUri() {
return m_uri;
}
/**
* Set namespace URI.
*
* @param uri namespace URI (null if not set)
*/
public void setUri(String uri) {
m_uri = uri;
}
/**
* Get specified namespace prefix.
*
* @return namespace prefix (null if not set)
*/
public String getPrefix() {
return m_prefix;
}
/**
* Set namespace prefix.
*
* @param prefix namespace prefix (null if not set)
*/
public void setPrefix(String prefix) {
m_prefix = prefix;
}
/**
* Get effective namespace definition. This call can only be used after
* validation.
*
* @return definition for namespace used by this name
*/
public NamespaceElement getNamespace() {
return m_namespace;
}
//
// Overrides of base class methods
/* (non-Javadoc)
* @see org.jibx.binding.model.AttributeBase#validate(org.jibx.binding.model.ValidationContext)
*/
public void validate(ValidationContext vctx) {
if (m_name != null) {
DefinitionContext dctx = null;
ElementBase elem = vctx.peekElement();
if (elem instanceof ContainerElementBase) {
dctx = ((ContainerElementBase)elem).getDefinitions();
}
if (dctx == null) {
dctx = vctx.getDefinitions();
}
if (m_isAttribute) {
m_namespace = dctx.getAttributeNamespace(this);
} else {
m_namespace = dctx.getElementNamespace(this, vctx);
String uri = getUri();
if (uri != null && m_namespace == null) {
vctx.addError("No namespace definition for URI " + uri);
}
}
}
super.validate(vctx);
}
/* (non-Javadoc)
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
if (obj instanceof NameAttributes) {
NameAttributes comp = (NameAttributes)obj;
if (Utility.safeEquals(m_name, comp.m_name)) {
if (m_namespace == null) {
return comp.m_namespace == null;
} else {
return Utility.safeEquals(m_namespace.getUri(),
comp.m_namespace.getUri());
}
} else {
return false;
}
} else {
return false;
}
}
/* (non-Javadoc)
* @see java.lang.Object#hashCode()
*/
public int hashCode() {
if (m_uri == null) {
return m_name.hashCode();
} else {
return m_name.hashCode() + m_uri.hashCode();
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/ModelVisitor.java 0000644 0001750 0001750 00000027421 11027507050 025647 0 ustar twerner twerner /*
Copyright (c) 2004-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
/**
* Binding model visitor base class. This works with the {@link
* org.jibx.binding.model.TreeContext} class for handling tree-based
* operations on the binding definition. Subclasses can override any or all of
* the base class visit and exit methods, including both those for abstract base
* classes and those for concrete classes, but should normally call the base
* class implementation of the method in order to implement the class
* inheritance hierarchy handling. Elements in the binding definition are always
* visited in tree order (down and across).
*
* @author Dennis M. Sosnoski
*/
public abstract class ModelVisitor
{
//
// Visit methods for base classes
/**
* Visit element. This method will be called for every element in the model.
*
* @param node element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(ElementBase node) {
return true;
}
/**
* Visit nesting element. This method will be called for any form of nesting
* element.
*
* @param node nesting element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(NestingElementBase node) {
return visit((ElementBase)node);
}
/**
* Visit container element. This method will be called for any form of
* container element.
*
* @param node container element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(ContainerElementBase node) {
return visit((NestingElementBase)node);
}
/**
* Visit structure element. This method will be called for any form of
* structure element.
*
* @param node structure element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(StructureElementBase node) {
return visit((ContainerElementBase)node);
}
/**
* Visit template element. This method will be called for any form of
* template element.
*
* @param node template element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(TemplateElementBase node) {
return visit((ContainerElementBase)node);
}
/**
* Visit mapping element.
*
* @param node mapping element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(MappingElementBase node) {
return visit((TemplateElementBase)node);
}
//
// Visit methods for concrete classes
/**
* Visit binding element.
*
* @param node binding element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(BindingElement node) {
return visit((NestingElementBase)node);
}
/**
* Visit collection element.
*
* @param node collection element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(CollectionElement node) {
return visit((StructureElementBase)node);
}
/**
* Visit format element.
*
* @param node format element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(FormatElement node) {
return visit((ElementBase)node);
}
/**
* Visit include element.
*
* @param node include element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(IncludeElement node) {
return visit((ElementBase)node);
}
/**
* Visit input element.
*
* @param node input element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(InputElement node) {
return visit((NestingElementBase)node);
}
/**
* Visit mapping element in normal binding.
*
* @param node mapping element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(MappingElement node) {
return visit((MappingElementBase)node);
}
/**
* Visit namespace element.
*
* @param node namespace element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(NamespaceElement node) {
return visit((ElementBase)node);
}
/**
* Visit output element.
*
* @param node output element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(OutputElement node) {
return visit((NestingElementBase)node);
}
/**
* Visit mapping element in precompiled binding.
*
* @param node mapping element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(PrecompiledMappingElement node) {
return visit((MappingElementBase)node);
}
/**
* Visit split element.
*
* @param node split element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(SplitElement node) {
return visit((NestingElementBase)node);
}
/**
* Visit structure element.
*
* @param node structure element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(StructureElement node) {
return visit((StructureElementBase)node);
}
/**
* Visit template element.
*
* @param node template element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(TemplateElement node) {
return visit((TemplateElementBase)node);
}
/**
* Visit value element.
*
* @param node value element being visited
* @return true if children to be processed, false
* if not
*/
public boolean visit(ValueElement node) {
return visit((ElementBase)node);
}
//
// Exit methods for base classes
/**
* Exit any element.
*
* @param node element being exited
*/
public void exit(ElementBase node) {}
/**
* Exit any nesting element.
*
* @param node nesting element being exited
*/
public void exit(NestingElementBase node) {
exit((ElementBase)node);
}
/**
* Exit any container element.
*
* @param node container element being exited
*/
public void exit(ContainerElementBase node) {
exit((NestingElementBase)node);
}
/**
* Exit any structure element.
*
* @param node structure element being exited
*/
public void exit(StructureElementBase node) {
exit((ContainerElementBase)node);
}
/**
* Exit any template element.
*
* @param node template element being exited
*/
public void exit(TemplateElementBase node) {
exit((NestingElementBase)node);
}
/**
* Exit any mapping element.
*
* @param node template element being exited
*/
public void exit(MappingElementBase node) {
exit((TemplateElementBase)node);
}
//
// Exit methods for concrete classes
/**
* Exit binding element.
*
* @param node binding element being exited
*/
public void exit(BindingElement node) {
exit((NestingElementBase)node);
}
/**
* Exit collection element.
*
* @param node collection element being exited
*/
public void exit(CollectionElement node) {
exit((StructureElementBase)node);
}
/**
* Exit include element.
*
* @param node input element being exited
*/
public void exit(IncludeElement node) {
exit((ElementBase)node);
}
/**
* Exit input element.
*
* @param node input element being exited
*/
public void exit(InputElement node) {
exit((NestingElementBase)node);
}
/**
* Exit mapping element in normal binding.
*
* @param node mapping element being exited
*/
public void exit(MappingElement node) {
exit((MappingElementBase)node);
}
/**
* Exit output element.
*
* @param node output element being exited
*/
public void exit(OutputElement node) {
exit((NestingElementBase)node);
}
/**
* Exit mapping element in precompiled binding.
*
* @param node mapping element being exited
*/
public void exit(PrecompiledMappingElement node) {
exit((MappingElementBase)node);
}
/**
* Exit split element.
*
* @param node split element being exited
*/
public void exit(SplitElement node) {
exit((NestingElementBase)node);
}
/**
* Exit structure element.
*
* @param node structure element being exited
*/
public void exit(StructureElement node) {
exit((StructureElementBase)node);
}
/**
* Exit template element.
*
* @param node template element being exited
*/
public void exit(TemplateElement node) {
exit((TemplateElementBase)node);
}
/**
* Exit value element.
*
* @param node value element being exited
*/
public void exit(ValueElement node) {
exit((ElementBase)node);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/StructureElementBase.java 0000644 0001750 0001750 00000032517 11153073224 027337 0 ustar twerner twerner /*
Copyright (c) 2004-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
import org.jibx.util.StringArray;
/**
* Model component for elements that define the binding structure for an object
* property. This is the base class for structure and collection
* elements.
*
* @author Dennis M. Sosnoski
*/
public abstract class StructureElementBase
extends ContainerElementBase implements IComponent
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new StringArray(PropertyAttributes.s_allowedAttributes,
NameAttributes.s_allowedAttributes),
ContainerElementBase.s_allowedAttributes);
/** Property attributes information for nesting. */
private PropertyAttributes m_propertyAttrs;
/** Name attributes information for nesting. */
private NameAttributes m_nameAttrs;
/** Flag for child of collection element (only meaningful after
prevalidation). */
private boolean m_collectionItem;
/**
* Constructor.
*
* @param type element type code
*/
protected StructureElementBase(int type) {
super(type);
m_nameAttrs = new NameAttributes();
m_propertyAttrs = new PropertyAttributes();
}
//
// Name attribute delegate methods
/**
* Get name.
*
* @return name text
*/
public String getName() {
return m_nameAttrs.getName();
}
/**
* Set name.
*
* @param name text for name
*/
public void setName(String name) {
m_nameAttrs.setName(name);
}
/**
* Get specified namespace URI.
*
* @return namespace URI (null if not set)
*/
public String getUri() {
return m_nameAttrs.getUri();
}
/**
* Set namespace URI.
*
* @param uri namespace URI (null if not set)
*/
public void setUri(String uri) {
m_nameAttrs.setUri(uri);
}
/**
* Get specified namespace prefix.
*
* @return namespace prefix (null if not set)
*/
public String getPrefix() {
return m_nameAttrs.getPrefix();
}
/**
* Set namespace prefix.
*
* @param prefix namespace prefix (null if not set)
*/
public void setPrefix(String prefix) {
m_nameAttrs.setPrefix(prefix);
}
/**
* Get effective namespace information. This call is only meaningful after
* validation.
*
* @return effective namespace information
*/
public NamespaceElement getNamespace() {
return m_nameAttrs.getNamespace();
}
//
// Property attribute delegate methods
/**
* Get usage name.
*
* @return usage name
*/
public String getUsageName() {
return m_propertyAttrs.getUsageName();
}
/**
* Get usage value. This call is only meaningful after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return usage value
*/
public int getUsage() {
return m_propertyAttrs.getUsage();
}
/**
* Set usage name.
*
* @param name usage name
*/
public void setUsageName(String name) {
m_propertyAttrs.setUsageName(name);
}
/**
* Set usage value.
*
* @param use value
*/
public void setUsage(int use) {
m_propertyAttrs.setUsage(use);
}
/**
* Check if property is defined. This method is only meaningful after
* a call to {@link #prevalidate(ValidationContext)}.
*
* @return true if property defined, false if not
*/
public boolean hasProperty() {
return m_propertyAttrs.hasProperty();
}
/**
* Check if property is flag only. This method is only meaningful after
* a call to {@link #prevalidate(ValidationContext)}.
*
* @return true if flag property, false if not
*/
public boolean isFlagOnly() {
return m_propertyAttrs.isFlagOnly();
}
/**
* Get declared type name.
*
* @return type name (or null if none)
*/
public String getDeclaredType() {
return m_propertyAttrs.getDeclaredType();
}
/**
* Set declared type name.
*
* @param type name (or null if none)
*/
public void setDeclaredType(String type) {
m_propertyAttrs.setDeclaredType(type);
}
/**
* Get field name.
*
* @return field name (or null if none)
*/
public String getFieldName() {
return m_propertyAttrs.getFieldName();
}
/**
* Get field information. This call is only meaningful after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return field information (or null if none)
*/
public IClassItem getField() {
return m_propertyAttrs.getField();
}
/**
* Set field name.
*
* @param field field name (or null if none)
*/
public void setFieldName(String field) {
m_propertyAttrs.setFieldName(field);
}
/**
* Get test method name.
*
* @return test method name (or null if none)
*/
public String getTestName() {
return m_propertyAttrs.getTestName();
}
/**
* Get test method information. This call is only meaningful after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return test method information (or null if none)
*/
public IClassItem getTest() {
return m_propertyAttrs.getTest();
}
/**
* Set test method name.
*
* @param test test method name (or null if none)
*/
public void setTestName(String test) {
m_propertyAttrs.setTestName(test);
}
/**
* Get flag method information. This call is only meaningful after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return flag method information (or null if none)
*/
public IClassItem getFlag() {
return m_propertyAttrs.getFlag();
}
/**
* Set flag method name.
*
* @param flag flag method name (or null if none)
*/
public void setFlagName(String flag) {
m_propertyAttrs.setFlagName(flag);
}
/**
* Get get method name.
*
* @return get method name (or null if none)
*/
public String getGetName() {
return m_propertyAttrs.getGetName();
}
/**
* Get get method information. This call is only meaningful after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return get method information (or null if none)
*/
public IClassItem getGet() {
return m_propertyAttrs.getGet();
}
/**
* Get type for value loaded to stack. This call is only meaningful after a
* call to {@link #prevalidate(ValidationContext)}.
*
* @return get value type (or null if none)
*/
public IClass getGetType() {
return m_propertyAttrs.getGetType();
}
/**
* Set get method name.
*
* @param get get method name (or null if none)
*/
public void setGetName(String get) {
m_propertyAttrs.setGetName(get);
}
/**
* Get set method name.
*
* @return set method name (or null if none)
*/
public String getSetName() {
return m_propertyAttrs.getSetName();
}
/**
* Get set method information. This call is only meaningful after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return set method information (or null if none)
*/
public IClassItem getSet() {
return m_propertyAttrs.getSet();
}
/**
* Get type for value stored from stack. This call is only meaningful after
* a call to {@link #prevalidate(ValidationContext)}.
*
* @return set value type (or null if none)
*/
public IClass getSetType() {
return m_propertyAttrs.getSetType();
}
/**
* Set set method name.
*
* @param set set method name (or null if none)
*/
public void setSetName(String set) {
m_propertyAttrs.setSetName(set);
}
/**
* Check if this value implicitly uses the containing object. This call
* is only meaningful after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return true if using the containing object,
* false if own value
*/
public boolean isImplicit() {
return m_propertyAttrs.isImplicit();
}
//
// Implementation methods
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#isOptional()
*/
public boolean isOptional() {
return m_propertyAttrs.getUsage() == PropertyAttributes.OPTIONAL_USAGE;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ContainerElementBase#hasObject()
*/
public boolean hasObject() {
return m_collectionItem || !isImplicit() || getDeclaredType() != null;
}
//
// Implementation of methods from IComponent interface (used in extensions)
/* (non-Javadoc)
* @see org.jibx.binding.model.IComponent#hasAttribute()
*/
public boolean hasAttribute() {
if (m_nameAttrs.getName() != null) {
return false;
} else {
return getAttributeComponents().size() > 0;
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IComponent#hasContent()
*/
public boolean hasContent() {
if (m_nameAttrs.getName() != null) {
return true;
} else {
return getContentComponents().size() > 0;
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IComponent#hasName()
*/
public boolean hasName() {
return m_nameAttrs.getName() != null;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IComponent#getType()
*/
public IClass getType() {
return m_propertyAttrs.getType();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ContainerElementBase#getType()
*/
public IClass getObjectType() {
return getType();
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#prevalidate(org.jibx.binding.model.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
m_nameAttrs.prevalidate(vctx);
m_propertyAttrs.prevalidate(vctx);
m_collectionItem = vctx.getParentContainer().type() == COLLECTION_ELEMENT;
if (!vctx.isSkipped(this)) {
super.prevalidate(vctx);
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#validate(org.jibx.binding.model.ValidationContext)
*/
public void validate(ValidationContext vctx) {
// validate the attribute groups
m_nameAttrs.validate(vctx);
m_propertyAttrs.validate(vctx);
if (!vctx.isSkipped(this)) {
// check for way of constructing object instance on input
if (m_propertyAttrs.hasProperty() && children().size() > 0) {
verifyConstruction(vctx, m_propertyAttrs.getType());
}
// check use of text values in children of structure with name
if (hasName()) {
SequenceVisitor visitor = new SequenceVisitor(this, vctx);
TreeContext tctx = vctx.getChildContext();
tctx.tourTree(this, visitor);
}
// finish with superclass validation
super.validate(vctx);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/BindingHolder.java 0000644 0001750 0001750 00000033110 11425317154 025735 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.binding.model;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.jibx.runtime.Utility;
import org.jibx.util.InsertionOrderedSet;
import org.jibx.util.LazyList;
/**
* External data for a binding definition. Along with the actual mapping definitions, this tracks namespace references
* and usages.
*
* @author Dennis M. Sosnoski
*/
public class BindingHolder
{
/** Organizer managing this holder. */
private final BindingOrganizer m_organizer;
/** Namespace URI associated with this binding (null if no-namespace binding). */
private final String m_namespace;
/** Namespace used by default for elements flag. */
private final boolean m_elementDefault;
/** Set of namespaces referenced in qualified names in this bindings. */
private final InsertionOrderedSet m_referencedNamespaces;
/** Set of namespaces used in element or attribute names in binding. */
private final InsertionOrderedSet m_usedNamespaces;
/** Prefix to be used for this namespace (null if unspecified). */
private String m_prefix;
/** Actual binding definition. */
private BindingElement m_binding;
/** Pull namespaces used in element or attribute names up to root binding flag (set when a type reference to this
binding is seen). */
private boolean m_pullUpNamespaces;
/** Binding namespace used for element or attribute flag. */
private boolean m_namespaceUsed;
/** Binding finalized flag. */
private boolean m_finished;
/** Name for file to be written from binding. */
private String m_fileName;
/** List of mapping definitions in binding. */
private final LazyList m_mappings;
/**
* Constructor.
* TODO: add a way of handling pregenerated bindings, so that namespaces can be properly tracked?
*
* @param uri (null if no-namespace binding)
* @param dflt namespace is default for elements flag
* @param dir directory managing this holder
*/
public BindingHolder(String uri, boolean dflt, BindingOrganizer dir) {
m_organizer = dir;
m_namespace = uri;
m_elementDefault = dflt;
m_referencedNamespaces = new InsertionOrderedSet();
m_usedNamespaces = new InsertionOrderedSet();
m_binding = new BindingElement();
m_mappings = new LazyList();
}
/**
* Get namespace URI associated with this binding.
*
* @return namespace (null if no-namespace)
*/
public String getNamespace() {
return m_namespace;
}
/**
* Get namespace prefix for this binding.
*
* @return prefix (null if not specified)
*/
public String getPrefix() {
return m_prefix;
}
/**
* Set namespace prefix for this binding. Method used by the binding organizer code to configure binding.
*
* @param prefix (null if not specified)
*/
/*default*/ void setPrefix(String prefix) {
m_prefix = prefix;
}
/**
* Get default namespace URI for elements defined in this binding.
*
* @return namespace (null if no-namespace)
*/
public String getElementDefaultNamespace() {
return m_elementDefault ? m_namespace : null;
}
/**
* Get the binding element.
*
* @return binding
*/
public BindingElement getBinding() {
return m_binding;
}
/**
* Set the binding element. This method is provided so that the generated binding element can be replaced by one
* which has been read in from a file after being written.
*
* @param bind
*/
public void setBinding(BindingElement bind) {
m_binding = bind;
}
/**
* Add a format definition to the binding. In actual generation, formats may be moved to a root binding definition.
*
* @param format
*/
public void addFormat(FormatElement format) {
m_organizer.addFormat(format);
}
/**
* Add usage of namespace for an element or attribute name in binding.
*
* @param uri referenced namespace URI (null if no-namespace)
*/
public void addNamespaceUsage(String uri) {
if (Utility.safeEquals(uri, m_namespace)) {
m_namespaceUsed = true;
} else {
m_organizer.addNamespaceUsage(this, uri);
m_usedNamespaces.add(uri);
}
}
/**
* Add reference from this binding to a type name defined in the same or another binding.
*
* @param uri namespace URI for type name
* @param obj object associated with referenced binding
*/
public void addTypeNameReference(String uri, Object obj) {
m_organizer.addTypeNameReference(this, uri, obj);
}
/**
* Internal check method to verify that the binding is still modifiable.
*/
private void checkModifiable() {
if (m_finished) {
throw new IllegalStateException("Internal error - attempt to modify binding after finalized");
}
}
/**
* Get the file name to be used for this file.
*
* @return name (null if not set)
*/
public String getFileName() {
return m_fileName;
}
/**
* Set the file name to be used for this file.
*
* @param name
*/
public void setFileName(String name) {
m_fileName = name;
}
/**
* Add a mapping definition to the binding.
*
* @param mapping
*/
public void addMapping(MappingElementBase mapping) {
checkModifiable();
m_mappings.add(mapping);
}
/**
* Get the number of mapping definitions present in this binding.
*
* @return count
*/
public int getMappingCount() {
return m_mappings.size();
}
/**
* Get the number of mapping definitions present in this binding.
*
* @return count
*/
public Iterator iterateMappings() {
return m_mappings.iterator();
}
/**
* Get the binding associated with a particular control object.
*
* @param obj object associated with binding (can be namespace URI, if only one binding per namespace)
* @return binding holder
*/
public BindingHolder getRequiredBinding(Object obj) {
return m_organizer.getRequiredBinding(obj);
}
/**
* Get a set of all the namespace URIs referenced by a qualified name in this binding. Method used by the binding
* organizer code to configure binding.
*
* @return live namespace list
*/
/*default*/ Set getReferencedNamespaces() {
return m_referencedNamespaces;
}
/**
* Get a set of all the namespace URIs used by element or attributes names in this binding. Method used by the
* binding organizer code to configure binding.
*
* @return live namespace list
*/
/*default*/ Set getUsedNamespaces() {
return m_usedNamespaces;
}
/**
* Force namespaces to be pulled up to the root binding. Method used by the binding organizer code to configure
* binding.
*/
/*default*/ void forcePullUpNamespaces() {
m_pullUpNamespaces = true;
}
/**
* Check if used namespaces need to be pulled up to the root binding. Method used by the binding organizer code to
* configure binding.
*
* @return pull up flag
*/
/*default*/ boolean isPullUpNamespaces() {
return m_pullUpNamespaces;
}
/**
* Check if the namespace associated with this binding should be used as the default for definitions in the binding.
* Method used by the binding organizer code to configure binding.
*
* @return pull up flag
*/
/*default*/ boolean isNamespaceElementDefault() {
return m_elementDefault;
}
/**
* Check if the namespace associated with this binding is actually used by any element or attribute definitions in
* the binding. Method used by the binding organizer code to configure binding.
*
* @return pull up flag
*/
/*default*/ boolean isBindingNamespaceUsed() {
return m_namespaceUsed;
}
/**
* Finishes building the binding. Method used by the binding organizer code to configure binding.
*
* @param formats format elements to be used in binding
* @param includes include elements to be used in binding
* @param outernss namespaces inherited by this binding
* @param nsdfltpref map from namespace URI to default prefix when used in a namespace declaration within the
* binding (null values for namespace used as the default)
* @param nsfrcdpref map from namespace URI to prefix when used in a binding namespace definition (prefix must be
* non-null and non-empty)
*/
/*default*/ void finish(Collection formats, Collection includes, Set outernss, Map nsdfltpref, Map nsfrcdpref) {
// make sure not already done
checkModifiable();
// add all required namespace declarations to binding element
List topchilds = m_binding.topChildren();
for (Iterator iter = m_referencedNamespaces.iterator(); iter.hasNext();) {
String uri = (String)iter.next();
if (uri != null) {
String prefix = (String)nsfrcdpref.get(uri);
if (prefix == null || prefix.length() == 0) {
throw new IllegalStateException("Internal error - no prefix for declaration of namespace " + uri);
}
m_binding.addNamespaceDecl(prefix, uri);
}
}
// add namespace element for the definitions in this binding
boolean elemdflt = m_elementDefault;
String dfltprfx = (String)nsdfltpref.get(m_namespace);
String prefix = m_prefix == null ? dfltprfx : m_prefix;
if ("".equals(prefix)) {
elemdflt = true;
}
if (m_namespace != null && m_namespaceUsed &&
(!outernss.contains(m_namespace) || (elemdflt && !"".equals(dfltprfx)))) {
NamespaceElement ns = new NamespaceElement();
ns.setUri(m_namespace);
if (elemdflt) {
ns.setDefaultName("elements");
}
if (!"".equals(prefix)) {
ns.setPrefix(prefix);
}
topchilds.add(ns);
}
// add all other required namespace definitions
for (Iterator iter = m_usedNamespaces.iterator(); iter.hasNext();) {
String uri = (String)iter.next();
if (uri != null) {
NamespaceElement ns = new NamespaceElement();
ns.setUri(uri);
ns.setPrefix((String)nsdfltpref.get(uri));
topchilds.add(ns);
}
}
// add formats, screening out any with no actual definitions to allow default handling of Java 5 enums
// (note that this may add namespace references, for type names on formats)
for (Iterator iter = formats.iterator(); iter.hasNext();) {
FormatElement format = (FormatElement)iter.next();
if (format.getDefaultText() != null || format.getDeserializerName() != null ||
format.getEnumValueName() != null || format.getSerializerName() != null || format.getQName() != null) {
topchilds.add(format);
// qualified names are not used directly for formats (instead using {uri}:lname), so no need for
// namespace declaration
// QName qname = format.getQName();
// if (qname != null) {
// // TODO: can I be sure that a prefix has been set?
// m_referencedNamespaces.add(qname.getUri());
// }
}
}
// follow formats with includes and accumulated mappings
topchilds.addAll(includes);
topchilds.addAll(m_mappings);
m_finished = true;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/NestingElementBase.java 0000644 0001750 0001750 00000012752 11126615316 026751 0 ustar twerner twerner /*
Copyright (c) 2004-2008, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.util.ArrayList;
import java.util.Iterator;
import org.jibx.util.StringArray;
/**
* Model component for elements that can contain other component elements.
* TODO: The list of child elements here conflicts with that in BindingElement;
* should change the type hierarchy to better reflect usage
*
* @author Dennis M. Sosnoski
*/
public abstract class NestingElementBase extends ElementBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "value-style" });
/** Value style attribute information. */
private NestingAttributes m_nestingAttrs;
/** Definition context for this nesting (created by validation). */
private DefinitionContext m_defContext;
/** List of child elements. */
private ArrayList m_children;
/**
* Constructor.
*
* @param type element type code
*/
protected NestingElementBase(int type) {
super(type);
m_nestingAttrs = new NestingAttributes();
m_children = new ArrayList();
}
/**
* Add child element.
* TODO: should be ElementBase argument, but JiBX doesn't allow yet
*
* @param child element to be added as child of this element
*/
public final void addChild(Object child) {
m_children.add(child);
}
/**
* Get list of child elements.
*
* @return list of child elements (never null)
*/
public final ArrayList children() {
return m_children;
}
/**
* Get iterator for child elements.
*
* @return iterator for child elements
*/
public final Iterator childIterator() {
return m_children.iterator();
}
/**
* Get definition context. This method may only be called after validation.
*
* @return definition context, or null if no definition context
* for this element
*/
public final DefinitionContext getDefinitions() {
return m_defContext;
}
/**
* Set definition context.
*
* @param ctx definition context to be set
*/
/*package*/ void setDefinitions(DefinitionContext ctx) {
m_defContext = ctx;
}
//
// Nesting attribute delegate methods
/**
* Get style name set on this nesting element.
*
* @return style string value (null if undefined at this level)
*/
public String getStyleName() {
return m_nestingAttrs.getStyleName();
}
/**
* Get style value set on this nesting element. This call is only meaningful
* after validation.
*
* @return style value (-1 if undefined at this level)
*/
public int getStyle() {
return m_nestingAttrs.getStyle();
}
/**
* Set style name on this nesting element.
*
* @param name style name (null to undefine style at this
* level)
*/
public void setStyleName(String name) {
m_nestingAttrs.setStyleName(name);
}
/**
* Get default style value for child components. This call is only
* meaningful after validation.
*
* @return default style value for child components (-1 if not
* defined at this level)
*/
public int getDefaultStyle() {
return m_nestingAttrs.getStyle();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#prevalidate(org.jibx.binding.model.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
m_nestingAttrs.prevalidate(vctx);
super.prevalidate(vctx);
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#validate(org.jibx.binding.model.ValidationContext)
*/
public void validate(ValidationContext vctx) {
if (m_defContext == null) {
m_defContext = vctx.getCurrentDefinitions();
}
m_nestingAttrs.validate(vctx);
super.validate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/RegistrationVisitor.java 0000644 0001750 0001750 00000016077 11524075706 027300 0 ustar twerner twerner /*
Copyright (c) 2004-2011, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.util.ArrayList;
/**
* Model visitor for handling item registration. This works with the {@link
* org.jibx.binding.model.ValidationContext} class to handle registration of
* items which can be referenced by name or by function (such as ID values
* within an object structure). The only items of this type which are not
* handled by this visitor are format definitions. The formats need to be
* accessed during prevalidation, so they're registered during that pass.
*
* @author Dennis M. Sosnoski
*/
public class RegistrationVisitor extends ModelVisitor
{
/** Validation context running this visitor. */
private final ValidationContext m_context;
/**
* Constructor.
*
* @param vctx validation context that will run this visitor
*/
public RegistrationVisitor(ValidationContext vctx) {
m_context = vctx;
}
/**
* Visit binding model tree to handle registration.
*
* @param root node of tree to be visited
*/
public void visitTree(ElementBase root) {
// first add all namespace declarations to contexts
m_context.tourTree(root, new ModelVisitor() {
/**
* Merge namespaces from containing binding into included binding.
*
* @param node
* @return continue expansion flag
*/
public boolean visit(IncludeElement node) {
BindingElement binding = node.getBinding();
if (binding != null && !node.isPrecompiled()) {
BindingElement contain =
(BindingElement)m_context.getParentElement();
DefinitionContext defs = binding.getDefinitions();
contain.getDefinitions().injectNamespaces(defs);
}
return super.visit(node);
}
/**
* Add namespace definition to containing context.
*
* @param node
* @return continue expansion flag
*/
public boolean visit(NamespaceElement node) {
ValidationProblem problem =
m_context.getCurrentDefinitions().addNamespace(node);
if (problem != null) {
m_context.addProblem(problem);
}
return super.visit(node);
}
/**
* Block expansion once a structure-type element is reached.
*
* @param node
* @return false
*/
public boolean visit(StructureElementBase node) {
return false;
}
});
// next handle adding references to table
m_context.tourTree(root, this);
// then handle mapping extension linkages with separate pass
m_context.tourTree(root, new ModelVisitor() {
// expand mapping elements in case child mappings are present
public boolean visit(MappingElement node) {
node.validateExtension(m_context);
return true;
}
// don't bother expanding structure elements
public boolean visit(StructureElementBase node) {
return false;
}
});
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ModelVisitor#visit(org.jibx.binding.model.ContainerElementBase)
*/
public boolean visit(ContainerElementBase node) {
if (node.getLabel() != null) {
ValidationProblem problem = m_context.getBindingRoot().
getDefinitions().addNamedStructure(node);
if (problem != null) {
m_context.addProblem(problem);
}
}
return super.visit(node);
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ModelVisitor#visit(org.jibx.binding.model.TemplateElementBase)
*/
public boolean visit(TemplateElementBase node) {
// check for a top-level definition
if (m_context.getParentElement() instanceof BindingElement) {
// add all namespace declarations from binding to template
DefinitionContext pctx =
m_context.getParentElement().getDefinitions();
if (pctx != null) {
ArrayList nss = pctx.getNamespaces();
if (nss != null) {
DefinitionContext nctx = node.getDefinitions();
if (nctx == null) {
nctx = new DefinitionContext(pctx);
node.setDefinitions(nctx);
}
for (int i = 0; i < nss.size(); i++) {
nctx.addNamespace((NamespaceElement)nss.get(i));
}
}
}
}
return super.visit(node);
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ModelVisitor#visit(org.jibx.binding.model.MappingElementBase)
*/
public boolean visit(MappingElementBase node) {
DefinitionContext dctx = m_context.getCurrentDefinitions();
dctx.addTemplate(node, m_context);
if (!node.isAbstract()) {
// force name validation to set the namespace information
NameAttributes name = node.getNameAttributes();
name.validate(m_context);
if (name != null && name.getName() != null) {
dctx.addMappedName(name, node, m_context);
}
}
return super.visit(node);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/CollectionElement.java 0000644 0001750 0001750 00000070142 11424510674 026641 0 ustar twerner twerner /*
Copyright (c) 2004-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
import org.jibx.util.StringArray;
/**
* Model component for collection element of binding definition.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class CollectionElement extends StructureElementBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "add-method", "item-type", "iter-method",
"load-method", "size-method", "store-method" },
StructureElementBase.s_allowedAttributes);
/** Load method name. */
private String m_loadMethodName;
/** Size method name. */
private String m_sizeMethodName;
/** Store method name. */
private String m_storeMethodName;
/** Add method name. */
private String m_addMethodName;
/** Iterator method name. */
private String m_iterMethodName;
/** Item type name. */
private String m_itemTypeName;
/** Load method information. */
private IClassItem m_loadMethodItem;
/** Size method information. */
private IClassItem m_sizeMethodItem;
/** Store method information. */
private IClassItem m_storeMethodItem;
/** Add method information. */
private IClassItem m_addMethodItem;
/** Iterator method information. */
private IClassItem m_iterMethodItem;
/** Item type information. */
private IClass m_itemTypeClass;
/**
* Default constructor.
*/
public CollectionElement() {
super(COLLECTION_ELEMENT);
}
/**
* Get item type name.
*
* @return item type name (or null if none)
*/
public String getItemTypeName() {
return m_itemTypeName;
}
/**
* Set item type name.
*
* @param type item type name (or null if none)
*/
public void setItemTypeName(String type) {
m_itemTypeName = type;
}
/**
* Get item type information. This call is only meaningful after
* validation.
*
* @return item type information
*/
public IClass getItemTypeClass() {
return m_itemTypeClass;
}
/**
* Get add method name.
*
* @return add method name (or null if none)
*/
public String getAddMethodName() {
return m_addMethodName;
}
/**
* Set add method name.
*
* @param name add method name (or null if none)
*/
public void setAddMethodName(String name) {
m_addMethodName = name;
}
/**
* Get add method information. This call is only meaningful after
* validation.
*
* @return add method information (or null if none)
*/
public IClassItem getAddMethodItem() {
return m_addMethodItem;
}
/**
* Get iterator method name.
*
* @return iterator method name (or null if none)
*/
public String getIterMethodName() {
return m_iterMethodName;
}
/**
* Set iterator method name.
*
* @param name iterator method name (or null if none)
*/
public void setIterMethodName(String name) {
m_iterMethodName = name;
}
/**
* Get iterator method information. This call is only meaningful after
* validation.
*
* @return iterator method information (or null if none)
*/
public IClassItem getIterMethodItem() {
return m_iterMethodItem;
}
/**
* Get load method name.
*
* @return load method name (or null if none)
*/
public String getLoadMethodName() {
return m_loadMethodName;
}
/**
* Set load method name.
*
* @param name load method name (or null if none)
*/
public void setLoadMethodName(String name) {
m_loadMethodName = name;
}
/**
* Get load method information. This call is only meaningful after
* validation.
*
* @return load method information (or null if none)
*/
public IClassItem getLoadMethodItem() {
return m_loadMethodItem;
}
/**
* Get size method name.
*
* @return size method name (or null if none)
*/
public String getSizeMethodName() {
return m_sizeMethodName;
}
/**
* Set size method name.
*
* @param name size method name (or null if none)
*/
public void setSizeMethodName(String name) {
m_sizeMethodName = name;
}
/**
* Get size method information. This call is only meaningful after
* validation.
*
* @return size method information (or null if none)
*/
public IClassItem getSizeMethodItem() {
return m_sizeMethodItem;
}
/**
* Get store method name.
*
* @return store method name (or null if none)
*/
public String getStoreMethodName() {
return m_storeMethodName;
}
/**
* Set store method name.
*
* @param name store method name (or null if none)
*/
public void setStoreMethodName(String name) {
m_storeMethodName = name;
}
/**
* Get store method information. This call is only meaningful after
* validation.
*
* @return store method information (or null if none)
*/
public IClassItem getStoreMethodItem() {
return m_storeMethodItem;
}
//
// Overrides of base class methods
/**
* Set ID property. This is never supported for an object coming from a
* collection.
*
* @param child child defining the ID property
* @return true if successful, false if ID
* already defined
*/
public boolean setIdChild(IComponent child) {
throw new IllegalStateException
("Internal error: method should never be called");
}
/**
* Check for object present. Always true for collection.
*
* @return true
*/
public boolean hasObject() {
return true;
}
/**
* Check for attribute definition. Always false for collection.
*
* @return false
*/
public boolean hasAttribute() {
return false;
}
/**
* Check for content definition. Always true for collection.
*
* @return true
*/
public boolean hasContent() {
return true;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ContainerElementBase#getChildObjectType()
*/
public IClass getChildObjectType() {
return getItemTypeClass();
}
//
// Validation methods
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
* @exception JiBXException on unmarshalling error
*/
private void preSet(IUnmarshallingContext uctx) throws JiBXException {
validateAttributes(uctx, s_allowedAttributes);
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#prevalidate(org.jibx.binding.model.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// first process attributes and check for errors
super.prevalidate(vctx);
if (!vctx.isSkipped(this)) {
// check for ignored attributes
if (isAllowRepeats()) {
vctx.addWarning("'allow-repeats' attribute ignored on collection");
}
if (isChoice()) {
vctx.addWarning("'choice' attribute ignored on collection");
}
// get the actual collection type and item type
IClass clas = getType();
if (clas == null) {
clas = vctx.getContextObject().getObjectType();
}
String tname = m_itemTypeName;
if (tname == null) {
String ctype = clas.getName();
if (ctype.endsWith("[]")) {
tname = ctype.substring(0, ctype.length()-2);
} else {
tname = "java.lang.Object";
}
}
m_itemTypeClass = vctx.getClassInfo(tname);
if (m_itemTypeClass == null) {
vctx.addFatal("Can't find class " + tname);
}
// handle input and output bindings separately
if (vctx.isInBinding()) {
// check store techniques
String sname = m_storeMethodName;
String aname = m_addMethodName;
if (sname != null && aname != null) {
vctx.addWarning("Both store-method and add-method supplied; using add-method");
sname = null;
}
if (vctx.isLookupSupported()) {
// set defaults based on collection type if needed
if (sname == null && aname == null) {
if (clas.isSuperclass("java.util.ArrayList") ||
clas.isSuperclass("java.util.Vector") ||
clas.isImplements("Ljava/util/Collection;")) {
aname = "add";
} else if (!clas.getName().endsWith("[]")) {
vctx.addError("Need store-method or add-method for input binding");
}
}
// find the actual method information
if (sname != null) {
m_storeMethodItem = clas.getBestMethod(sname,
null, new String[] { "int", tname });
if (m_storeMethodItem == null) {
vctx.addError("store-method " + sname +
" not found in class " + clas.getName());
}
}
if (aname != null) {
m_addMethodItem = clas.getBestMethod(aname,
null, new String[] { tname });
if (m_addMethodItem == null) {
vctx.addError("add-method " + aname +
" not found in class " + clas.getName());
}
}
}
}
if (vctx.isOutBinding()) {
// precheck load techniques
String lname = m_loadMethodName;
String sname = m_sizeMethodName;
String iname = m_iterMethodName;
if (lname == null) {
if (sname != null) {
vctx.addWarning("size-method requires load-method; ignoring supplied size-method");
sname = null;
}
} else {
if (sname == null) {
vctx.addWarning("load-method requires size-method; ignoring supplied load-method");
lname = null;
} else {
if (iname != null) {
vctx.addWarning("Both load-method and iter-method supplied; using load-method");
iname = null;
}
}
}
if (vctx.isLookupSupported()) {
// set defaults based on collection type if needed
if (lname == null && iname == null) {
if (clas.isSuperclass("java.util.ArrayList") ||
clas.isSuperclass("java.util.Vector")) {
lname = "get";
sname = "size";
} else if (clas.isImplements("Ljava/util/Collection;")) {
iname = "iterator";
}
}
// postcheck load techniques with defaults set
if (lname == null) {
if (iname == null && !clas.getName().endsWith("[]")) {
vctx.addError("Need load-method and size-method, or iter-method, for output binding");
}
} else {
if (sname == null && iname == null) {
vctx.addError("Need load-method and size-method, or iter-method, for output binding");
}
}
// find the actual method information
if (lname != null) {
m_loadMethodItem = clas.getBestMethod(lname,
tname, new String[] { "int" });
if (m_loadMethodItem == null) {
vctx.addError("load-method " + lname +
" not found in class " + clas.getName());
}
}
if (iname != null) {
m_iterMethodItem = clas.getBestMethod(iname,
"java.util.Iterator", new String[0]);
if (m_iterMethodItem == null) {
vctx.addError("iter-method " + iname +
" not found in class " + clas.getName());
}
}
}
}
}
}
/**
* Check that child components are of types compatible with the collection
* item-type. This method may call itself recursively to process the
* children of child components which do not themselves set a type. The
* result is used for recursive checking to detect conditions where an
* inner structure defines a type but an outer one does not (which causes
* errors in the current code generation).
*
* @param vctx validation context
* @param type collection item type
* @param children list of child components to be checked
* @return true if only child is a <value> element with
* type, false if not
*/
private boolean checkCollectionChildren(ValidationContext vctx,
IClass type, ArrayList children) {
boolean valonly = children.size() == 1;
for (int i = 0; i < children.size(); i++) {
ElementBase child = (ElementBase)children.get(i);
if (!vctx.isSkipped(child)) {
// track whether children of this child must be type-checked
boolean expand = true;
valonly = valonly && (child instanceof ValueElement);
if (child instanceof IComponent) {
// first make sure a name is present
IComponent comp = (IComponent)child;
if (vctx.isInBinding() && !comp.hasName() &&
comp instanceof ValueElement) {
vctx.addFatal(" elements within a collection must define element name for unmarshalling", comp);
}
// find the type associated with this component (if any)
IClass ctype = comp.getType();
expand = false;
if (comp instanceof ContainerElementBase) {
ContainerElementBase contain = (ContainerElementBase)comp;
if (contain.hasObject()) {
ctype = contain.getObjectType();
} else {
expand = true;
}
}
// see if a type was found (no need to look at children)
if (!expand) {
// verify that type is compatible with collection
if (!ctype.isAssignable(type)) {
vctx.addFatal("References to collection items must use compatible types: " +
ctype.getName() + " cannot be used as " +
type.getName(), child);
}
}
}
// recurse on children if necessary for type-checking
if (expand && child instanceof NestingElementBase) {
NestingElementBase nest = (NestingElementBase)child;
if (nest.children().size() > 0) {
// type check child definitions
boolean valchild = checkCollectionChildren(vctx, type,
((NestingElementBase)child).children());
// now check for structure element with no type
if (!valchild && child instanceof StructureElement) {
vctx.addError("Type must be specified on outermost element within collection", child);
}
}
}
}
}
return valonly;
}
/**
* Check children of unordered collection for consistency. In an input
* binding each child element must define a unique qualified name. In an
* output binding each child element must define a unique type or supply
* a test method to allow checking when that element should be generated for
* an object.
*
* @param vctx validation context
* @param children list of child components
*/
private void checkUnorderedChildren(ValidationContext vctx,
ArrayList children) {
HashMap typemap = new HashMap();
HashMap namemap = new HashMap();
for (int i = 0; i < children.size(); i++) {
ElementBase child = (ElementBase)children.get(i);
if (child instanceof IComponent && !vctx.isSkipped(child)) {
IComponent comp = (IComponent)child;
if (vctx.isInBinding()) {
// names must be distinct in input binding
String name = comp.getName();
String uri = comp.getUri();
if (uri == null) {
uri = "";
}
Object value = namemap.get(name);
if (value == null) {
// first instance of name, store directly
namemap.put(name, comp);
} else if (value instanceof HashMap) {
// multiple instances already found, match on URI
HashMap urimap = (HashMap)value;
if (urimap.get(uri) != null) {
vctx.addError("Duplicate names are not allowed in unordered collection", comp);
} else {
urimap.put(uri, comp);
}
} else {
// duplicate name, check URI
IComponent match = (IComponent)value;
if ((uri == null && match.getUri() == null) ||
(uri != null && uri.equals(match.getUri()))) {
vctx.addError("Duplicate names are not allowed in unordered collection", comp);
} else {
// multiple namespaces for same name, use map
HashMap urimap = new HashMap();
urimap.put(uri, comp);
String muri = match.getUri();
if (muri == null) {
muri = "";
}
urimap.put(muri, match);
namemap.put(name, urimap);
}
}
}
if (vctx.isOutBinding()) {
// just accumulate lists of each type in this loop
String type = comp.getType().getName();
Object value = typemap.get(type);
if (value == null) {
typemap.put(type, comp);
} else if (value instanceof ArrayList) {
ArrayList types = (ArrayList)value;
types.add(comp);
} else {
ArrayList types = new ArrayList();
types.add(value);
types.add(comp);
typemap.put(type, types);
}
}
}
}
// check for duplicate type usage in output binding
for (Iterator iter = typemap.values().iterator(); iter.hasNext();) {
Object value = iter.next();
if (value instanceof ArrayList) {
// multiple instances of type, make sure we can distinguish
ArrayList types = (ArrayList)value;
for (int i = 0; i < types.size(); i++) {
Object child = types.get(i);
if (child instanceof ValueElement) {
ValueElement vel = (ValueElement)child;
if (vel.getTest() == null) {
vctx.addError("test-method needed for multiple instances of same type in unordered collection", vel);
}
} else if (child instanceof StructureElementBase) {
StructureElementBase sel = (StructureElementBase)child;
if (sel.getTest() == null) {
vctx.addError("test-method needed for multiple instances of same type in unordered collection", sel);
}
}
}
}
}
}
/**
* Check children of ordered collection for consistency. In an input binding
* each child element must use a different qualified name from the preceding
* child element. In an output binding each child element must define a
* different type from the preceding child element, or the preceding child
* element must supply a test method to allow checking when that element
* should be generated for an object.
*
* @param vctx validation context
* @param children list of child components
*/
private void checkOrderedChildren(ValidationContext vctx,
ArrayList children) {
IComponent prior = null;
for (int i = 0; i < children.size(); i++) {
ElementBase child = (ElementBase)children.get(i);
if (child instanceof IComponent && !vctx.isSkipped(child)) {
IComponent comp = (IComponent)child;
if (prior == null) {
prior = comp;
} else {
if (vctx.isInBinding()) {
// make sure names are different
String uri = comp.getUri();
String cname = comp.getName();
String pname = prior.getName();
if (cname != null && pname != null &&
cname.equals(pname) &&
((uri == null && prior.getUri() == null) ||
(uri != null && uri.equals(prior.getUri())))) {
vctx.addError("Successive elements of collection cannot use duplicate names for unmarshalling", comp);
}
}
if (vctx.isOutBinding()) {
// make sure types differ or test method supplied
IClass type = comp.getType();
if (type.isAssignable(prior.getType())) {
IClassItem test = null;
if (prior instanceof ValueElement) {
test = ((ValueElement)prior).getTest();
} else if (prior instanceof StructureElementBase) {
test = ((StructureElementBase)prior).getTest();
}
if (test == null) {
vctx.addError("Collection component must specify a test-method to distinguish from next component of compatible type for marshalling", prior);
}
}
}
}
}
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#validate(org.jibx.binding.model.ValidationContext)
*/
public void validate(ValidationContext vctx) {
// call base class method first
super.validate(vctx);
// check for way to determine if named collection present on output
if (vctx.isOutBinding() && hasName() && !hasProperty() &&
isOptional() && getTest() == null &&
!(vctx.getParentContainer() instanceof CollectionElement)) {
vctx.addError
("Need test method for optional collection output element");
}
// TODO: this should really check that item-type on an empty collection
// specifies a concrete mapping
// make sure only element components are present
ArrayList children = children();
for (int i = 0; i < children.size(); i++) {
IComponent child = (IComponent)children.get(i);
if (child.hasAttribute()) {
vctx.addFatal
("Attributes not allowed as child components of collection",
child);
}
}
// check each child component
checkCollectionChildren(vctx, m_itemTypeClass, children);
// make sure child components can be distinguished
if (children.size() > 1) {
if (isOrdered()) {
checkOrderedChildren(vctx, children);
} else {
checkUnorderedChildren(vctx, children);
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/TemplateElement.java 0000644 0001750 0001750 00000015257 11072762652 026333 0 ustar twerner twerner /*
Copyright (c) 2004-2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
/**
* Model component for template element of binding definition.
*
* @author Dennis M. Sosnoski
*/
public class TemplateElement extends TemplateElementBase
{
/** Template label. */
private String m_label;
/** Default template for type flag. */
private boolean m_isDefault;
/** Schema type name for xsi:type. */
private NameAttributes m_typeNameAttrs;
/** Base schema type name for xsi:type. */
private NameAttributes m_baseNameAttrs;
/** Base template extended by this one. */
private TemplateElement m_extendsMapping;
/**
* Default constructor.
*/
public TemplateElement() {
super(TEMPLATE_ELEMENT);
m_typeNameAttrs = new NameAttributes();
}
/**
* Get template label.
*
* @return template label (null if none)
*/
public String getLabel() {
return m_label;
}
/**
* Set template label.
*
* @param label template label (null if none)
*/
public void setLabel(String label) {
m_label = label;
}
/**
* Check if default template for type.
*
* @return true if default for type, false if not
*/
public boolean isDefaultTemplate() {
return m_isDefault;
}
/**
* Set default template for type flag.
*
* @param dflt true if default for type, false if
* not
*/
public void setDefaultTemplate(boolean dflt) {
m_isDefault = dflt;
}
//
// Type name attribute delegate methods
/**
* Get type name.
*
* @return type name text
*/
public String getTypeName() {
return m_typeNameAttrs.getName();
}
/**
* Set type name.
*
* @param name text for type name
*/
public void setTypeName(String name) {
m_typeNameAttrs.setName(name);
}
/**
* Get namespace URI specified for type.
*
* @return type namespace URI (null if not set)
*/
public String getTypeUri() {
return m_typeNameAttrs.getUri();
}
/**
* Set type namespace URI.
*
* @param uri type namespace URI (null if not set)
*/
public void setTypeUri(String uri) {
m_typeNameAttrs.setUri(uri);
}
/**
* Get namespace prefix specified for type.
*
* @return type namespace prefix (null if not set)
*/
public String getTypePrefix() {
return m_typeNameAttrs.getPrefix();
}
/**
* Set type namespace prefix.
*
* @param prefix namespace prefix (null if not set)
*/
public void setTypePrefix(String prefix) {
m_typeNameAttrs.setPrefix(prefix);
}
/**
* Get effective namespace information for type. This call is only
* meaningful after validation.
*
* @return effective namespace information
*/
public NamespaceElement getTypeNamespace() {
return m_typeNameAttrs.getNamespace();
}
/**
* Get template extended by this one.
*
* @return template extended by this one
*/
public TemplateElement getExtendsMapping() {
return m_extendsMapping;
}
//
// Base type name attribute delegate methods
/**
* Get base type name.
*
* @return base type name text
*/
public String getBaseName() {
return m_baseNameAttrs.getName();
}
/**
* Set base type name.
*
* @param name text for base type name
*/
public void setBaseName(String name) {
m_baseNameAttrs.setName(name);
}
/**
* Get namespace URI specified for base type.
*
* @return base type namespace URI (null if not set)
*/
public String getBaseUri() {
return m_baseNameAttrs.getUri();
}
/**
* Set base type namespace URI.
*
* @param uri base type namespace URI (null if if not set)
*/
public void setBaseUri(String uri) {
m_baseNameAttrs.setUri(uri);
}
/**
* Get namespace URI specified for base type.
*
* @return base type namespace prefix (null if not set)
*/
public String getBasePrefix() {
return m_baseNameAttrs.getPrefix();
}
/**
* Set base type namespace prefix.
*
* @param prefix base type namespace prefix (null if not set)
*/
public void setBasePrefix(String prefix) {
m_baseNameAttrs.setPrefix(prefix);
}
/**
* Get effective namespace information for base type. This call is only
* meaningful after validation.
*
* @return effective namespace information
*/
public NamespaceElement getBaseNamespace() {
return m_typeNameAttrs.getNamespace();
}
//
// Validation methods
/**
* Prevalidate attributes of element in isolation.
*
* @param vctx validation context
*/
public void prevalidate(ValidationContext vctx) {
m_typeNameAttrs.prevalidate(vctx);
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/TemplateElementBase.java 0000644 0001750 0001750 00000014750 11062041124 027102 0 ustar twerner twerner /*
Copyright (c) 2004-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.util.ArrayList;
import java.util.Iterator;
import org.jibx.util.IClass;
import org.jibx.util.StringArray;
/**
* Model component for elements that define how instances of a particular class
* are converted to or from XML. This includes both mapping and
* template elements.
*
* @author Dennis M. Sosnoski
*/
public abstract class TemplateElementBase extends ContainerElementBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "class" },
ContainerElementBase.s_allowedAttributes);
/** Name of handled class. */
private String m_className;
/** Handled class information. */
private IClass m_handledClass;
/** List of child elements. */
protected ArrayList m_topChildren;
/** Templates or mappings that can be used in place of this one (as
* substitution group using mapping, or xsi:type with template). */
private ArrayList m_extensionTypes;
/**
* Constructor.
*
* @param type element type code
*/
public TemplateElementBase(int type) {
super(type);
m_extensionTypes = new ArrayList();
}
/**
* Set mapped class name.
*
* @param name mapped class name
*/
public void setClassName(String name) {
m_className = name;
}
/**
* Get mapped class name.
*
* @return class name
*/
public String getClassName() {
return m_className;
}
/**
* Get handled class information. This call is only meaningful after
* prevalidation.
*
* @return mapped class information
*/
public IClass getHandledClass() {
return m_handledClass;
}
/**
* Add template or mapping which derives from this one.
*
* @param ext derived template or mapping information
*/
protected void addExtensionType(TemplateElementBase ext) {
m_extensionTypes.add(ext);
}
/**
* Get templates or mappings which derive from this one.
*
* @return list of derived templates or mappings
*/
public ArrayList getExtensionTypes() {
return m_extensionTypes;
}
/**
* Check if default template for type. Needs to be implemented by subclasses
* for common handling.
*
* @return true if default for type, false if not
*/
public abstract boolean isDefaultTemplate();
/**
* Add top-level child element.
*
* @param child element to be added as child of this element
*/
public void addTopChild(Object child) {
m_topChildren.add(child);
}
/**
* Get list of top-level child elements.
*
* @return list of child elements, or null if none
*/
public ArrayList topChildren() {
return m_topChildren;
}
/**
* Get iterator for top-level child elements.
*
* @return iterator for child elements
*/
public Iterator topChildIterator() {
return m_topChildren.iterator();
}
//
// Overrides of base class methods
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#isOptional()
*/
public boolean isOptional() {
throw new IllegalStateException
("Internal error: method should never be called");
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IContextObj#getType()
*/
public IClass getType() {
return m_handledClass;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ContainerElementBase#isImplicit()
*/
public boolean isImplicit() {
return false;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ContainerElementBase#hasObject()
*/
public boolean hasObject() {
return true;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ContainerElementBase#getObjectType()
*/
public IClass getObjectType() {
return m_handledClass;
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#prevalidate(org.jibx.binding.model.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
if (m_className == null) {
vctx.addFatal("Class name is required");
} else {
m_handledClass = vctx.getClassInfo(m_className);
if (m_handledClass == null) {
vctx.addFatal("Cannot find information for class " +
m_className);
} else {
super.prevalidate(vctx);
}
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ContainerElementBase#validate(org.jibx.binding.model.ValidationContext)
*/
public void validate(ValidationContext vctx) {
// check each child component for compatible type
ArrayList children = children();
checkCompatibleChildren(vctx, m_handledClass, children);
super.validate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/ClassWrapper.java 0000644 0001750 0001750 00000025052 11062041122 025623 0 ustar twerner twerner /*
Copyright (c) 2004-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.ClassItem;
import org.jibx.runtime.JiBXException;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
import org.jibx.util.IClassLocator;
/**
* Wrapper for class information. This wraps the BCEL-based class handling
* implementation to support the interface defined for use with the binding
* model.
*
* @author Dennis M. Sosnoski
*/
public class ClassWrapper implements IClass
{
private final IClassLocator m_locator;
private final ClassFile m_class;
private IClassItem[] m_fields;
private IClassItem[] m_methods;
/**
* Constructor.
*
* @param loc
* @param clas
*/
public ClassWrapper(IClassLocator loc, ClassFile clas) {
m_locator = loc;
m_class = clas;
}
/**
* Build an item wrapper. This method may be overridden by subclasses to
* return a specialized form of wrapper.
*
* @param item
* @return wrapper
*/
protected IClassItem buildItem(ClassItem item) {
return new ClassItemWrapper(this, item);
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getName()
*/
public String getName() {
return m_class.getName();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getSignature()
*/
public String getSignature() {
return m_class.getSignature();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getPackage()
*/
public String getPackage() {
return m_class.getPackage();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getSuperClass()
*/
public IClass getSuperClass() {
ClassFile scf = m_class.getSuperFile();
if (scf == null) {
return null;
} else {
return new ClassWrapper(m_locator, m_class.getSuperFile());
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getInterfaces()
*/
public String[] getInterfaces() {
return m_class.getInterfaces();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getInstanceSigs()
*/
public String[] getInstanceSigs() {
try {
return m_class.getInstanceSigs();
} catch (JiBXException e) {
// TODO need to handle this differently - perhaps get all when created
throw new IllegalStateException("Internal error: instance " +
"signatures not found for class " + m_class.getName());
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#isImplements(java.lang.String)
*/
public boolean isImplements(String sig) {
try {
return m_class.isImplements(sig);
} catch (JiBXException e) {
// TODO need to handle this differently - perhaps get all when created
throw new IllegalStateException("Internal error: instance " +
"signatures not found for class " + m_class.getName());
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#isAbstract()
*/
public boolean isAbstract() {
return m_class.isAbstract();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#isInterface()
*/
public boolean isInterface() {
return m_class.isInterface();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#isModifiable()
*/
public boolean isModifiable() {
return m_class.isModifiable();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#isSuperclass(org.jibx.binding.model.IClass)
*/
public boolean isSuperclass(String name) {
ClassFile current = m_class;
while (current != null) {
if (current.getName().equals(name)) {
return true;
} else {
current = current.getSuperFile();
}
}
return false;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getDirectField(java.lang.String)
*/
public IClassItem getDirectField(String name) {
ClassItem item = m_class.getDirectField(name);
if (item == null) {
return null;
} else {
return buildItem(item);
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getField(java.lang.String)
*/
public IClassItem getField(String name) {
try {
return buildItem(m_class.getField(name));
} catch (JiBXException e) {
// TODO need to handle this differently - perhaps get all when created
return null;
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getMethod(java.lang.String, java.lang.String)
*/
public IClassItem getMethod(String name, String sig) {
ClassItem item = m_class.getMethod(name, sig);
if (item == null) {
return null;
} else {
return buildItem(item);
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getMethod(java.lang.String, java.lang.String[])
*/
public IClassItem getMethod(String name, String[] sigs) {
ClassItem item = m_class.getMethod(name, sigs);
if (item == null) {
return null;
} else {
return buildItem(item);
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getInitializerMethod(java.lang.String)
*/
public IClassItem getInitializerMethod(String sig) {
ClassItem item = m_class.getInitializerMethod(sig);
if (item == null) {
return null;
} else {
return buildItem(item);
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getStaticMethod(java.lang.String, java.lang.String)
*/
public IClassItem getStaticMethod(String name, String sig) {
ClassItem item = m_class.getStaticMethod(name, sig);
if (item == null) {
return null;
} else {
return buildItem(item);
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#isAccessible(org.jibx.binding.model.IClassItem)
*/
public boolean isAccessible(IClassItem item) {
return m_class.isAccessible(((ClassItemWrapper)item).getClassItem());
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#isAssignable(org.jibx.binding.model.IClass)
*/
public boolean isAssignable(IClass other) {
String[] sigs;
try {
sigs = m_class.getInstanceSigs();
} catch (JiBXException e) {
throw new IllegalStateException
("Internal error: class information not available");
}
String match = other.getSignature();
for (int i = 0; i < sigs.length; i++) {
if (match.equals(sigs[i])) {
return true;
}
}
return false;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getBestMethod(java.lang.String, java.lang.String, java.lang.String[])
*/
public IClassItem getBestMethod(String name, String type, String[] args) {
ClassItem item = m_class.getBestMethod(name, type, args);
if (item == null) {
return null;
} else {
return buildItem(item);
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getClassFile()
* TODO: eliminate this method
*/
public ClassFile getClassFile() {
return m_class;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#loadClass()
*/
public Class loadClass() {
String name = m_class.getName();
Class clas = ClassFile.loadClass(name);
if (clas == null) {
// TODO: this is a kludge
try {
clas = ClassUtils.class.getClassLoader().loadClass(name);
} catch (ClassNotFoundException ex) { /* deliberately empty */ }
}
return clas;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getFields()
*/
public IClassItem[] getFields() {
if (m_fields == null) {
ClassItem[] items = m_class.getFieldItems();
m_fields = new IClassItem[items.length];
for (int i = 0; i < items.length; i++) {
m_fields[i] = buildItem(items[i]);
}
}
return m_fields;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getMethods()
*/
public IClassItem[] getMethods() {
if (m_methods == null) {
ClassItem[] items = m_class.getMethodItems();
m_methods = new IClassItem[items.length];
for (int i = 0; i < items.length; i++) {
m_methods[i] = buildItem(items[i]);
}
}
return m_methods;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getJavaDoc()
*/
public String getJavaDoc() {
return null;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClass#getLocator()
*/
public IClassLocator getLocator() {
return m_locator;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/ValidationProblem.java 0000644 0001750 0001750 00000010702 10602536560 026642 0 ustar twerner twerner /*
Copyright (c) 2004-2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import org.jibx.runtime.ITrackSource;
import org.jibx.runtime.ValidationException;
/**
* Problem reported by model validation. Provides the details for a specific
* problem item.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class ValidationProblem
{
// severity levels
public static final int WARNING_LEVEL = 0;
public static final int ERROR_LEVEL = 1;
public static final int FATAL_LEVEL = 2;
/** Problem severity level. */
private final int m_severity;
/** Supplied problem description message. */
private final String m_message;
/** Component that reported problem. */
private final Object m_component;
/**
* Full constructor.
*
* @param level severity level of problem
* @param msg problem description
* @param obj source object for validation error (may be null
* if not specific to a particular component)
*/
/*package*/ ValidationProblem(int level, String msg, Object obj) {
m_severity = level;
m_message = msg;
m_component = obj;
}
/**
* Create description text for a component of a binding definition.
*
* @param obj binding definition component
* @return description
*/
public static String componentDescription(Object obj) {
StringBuffer buff = new StringBuffer();
if (obj instanceof ElementBase) {
buff.append(ElementBase.ELEMENT_NAMES[((ElementBase)obj).type()]);
buff.append(" element");
} else {
String cname = obj.getClass().getName();
int split = cname.lastIndexOf('.');
if (split >= 0) {
cname = cname.substring(split+1);
}
buff.append(cname);
}
if (obj instanceof ITrackSource) {
buff.append(" at ");
buff.append(ValidationException.describe(obj));
} else {
buff.append(" at unknown location");
}
return buff.toString();
}
/**
* Constructor using default (error) severity level.
*
* @param msg problem description
* @param obj source object for validation error
*/
/*package*/ ValidationProblem(String msg, Object obj) {
this(ERROR_LEVEL, msg, obj);
}
/**
* Get the main binding definition item for the problem.
*
* @return element or attribute at root of problem
*/
public Object getComponent() {
return m_component;
}
/**
* Get problem description.
*
* @return problem description
*/
public String getDescription() {
if (m_component == null) {
return m_message;
} else {
return m_message + "; on " + componentDescription(m_component);
}
}
/**
* Get problem severity level.
*
* @return severity level for problem
*/
public int getSeverity() {
return m_severity;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/ObjectAttributes.java 0000644 0001750 0001750 00000044067 11424510302 026504 0 ustar twerner twerner /*
Copyright (c) 2004-2010, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
import org.jibx.util.StringArray;
/**
* Model component for object attribute group in binding definition.
*
* @author Dennis M. Sosnoski
*/
public class ObjectAttributes extends AttributeBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "create-type", "factory", "marshaller",
"nillable", "post-set", "pre-get", "pre-set", "unmarshaller" });
//
// Constants and such related to code generation.
// recognized marshal hook method (pre-get) signatures.
private static final String[] MARSHAL_HOOK_SIGNATURES =
{
"(Lorg/jibx/runtime/IMarshallingContext;)V",
"(Ljava/lang/Object;)V",
"()V"
};
// recognized factory hook method signatures.
private static final String[] FACTORY_HOOK_SIGNATURES =
{
"(Lorg/jibx/runtime/IUnmarshallingContext;)",
"(Ljava/lang/Object;)",
"()"
};
// recognized unmarshal hook method (pre-set, post-set) signatures.
private static final String[] UNMARSHAL_HOOK_SIGNATURES =
{
"(Lorg/jibx/runtime/IUnmarshallingContext;)V",
"(Ljava/lang/Object;)V",
"()V"
};
// marshaller/unmarshaller definitions
private static final String UNMARSHALLER_INTERFACE =
"org.jibx.runtime.IUnmarshaller";
private static final String MARSHALLER_INTERFACE =
"org.jibx.runtime.IMarshaller";
private static final String UNMARSHALLER_INTERFACETYPE =
"Lorg/jibx/runtime/IUnmarshaller;";
private static final String MARSHALLER_INTERFACETYPE =
"Lorg/jibx/runtime/IMarshaller;";
//
// Instance data.
/** Factory method name (fully qualified, including package and class). */
private String m_factoryName;
/** Pre-set method name. */
private String m_preSetName;
/** Post-set method name. */
private String m_postSetName;
/** Pre-get method name. */
private String m_preGetName;
/** Object marshaller class name. */
private String m_marshallerName;
/** Object unmarshaller class name. */
private String m_unmarshallerName;
/** Nillable object flag. */
private boolean m_isNillable;
/** Instance type for creation (fully qualified, including package and
class). */
private String m_createType;
/** Factory method information. */
private IClassItem m_factoryItem;
/** Pre-set method information. */
private IClassItem m_preSetItem;
/** Post-set method information. */
private IClassItem m_postSetItem;
/** Pre-get method information. */
private IClassItem m_preGetItem;
/** Object marshaller class. */
private IClass m_marshallerClass;
/** Object unmarshaller class. */
private IClass m_unmarshallerClass;
/** Class to use for new instance creation. */
private IClass m_createClass;
/**
* Constructor.
*/
public ObjectAttributes() {}
/**
* Get factory method name.
*
* @return fully-qualified factory class and method name (or
* null if none)
*/
public String getFactoryName() {
return m_factoryName;
}
/**
* Get factory method information. This method is only usable after a
* call to {@link #prevalidate(ValidationContext)}.
*
* @return factory method information (or null if none)
*/
public IClassItem getFactory() {
return m_factoryItem;
}
/**
* Set factory method name.
*
* @param name fully qualified class and method name for object factory
*/
public void setFactoryName(String name) {
m_factoryName = name;
}
/**
* Get pre-set method name.
*
* @return pre-set method name (or null if none)
*/
public String getPresetName() {
return m_preSetName;
}
/**
* Get pre-set method information. This method is only usable after a
* call to {@link #prevalidate(ValidationContext)}.
*
* @return pre-set method information (or null if none)
*/
public IClassItem getPreset() {
return m_preSetItem;
}
/**
* Set pre-set method name.
*
* @param name member method name to be called before unmarshalling
*/
public void setPresetName(String name) {
m_preSetName = name;
}
/**
* Get post-set method name.
*
* @return post-set method name (or null if none)
*/
public String getPostsetName() {
return m_postSetName;
}
/**
* Get post-set method information. This method is only usable after a
* call to {@link #prevalidate(ValidationContext)}.
*
* @return post-set method information (or null if none)
*/
public IClassItem getPostset() {
return m_postSetItem;
}
/**
* Set post-set method name.
*
* @param name member method name to be called after unmarshalling
*/
public void setPostsetName(String name) {
m_postSetName = name;
}
/**
* Get pre-get method name.
*
* @return pre-get method name (or null if none)
*/
public String getPregetName() {
return m_preGetName;
}
/**
* Get pre-get method information. This method is only usable after a
* call to {@link #prevalidate(ValidationContext)}.
*
* @return pre-get method information (or null if none)
*/
public IClassItem getPreget() {
return m_preGetItem;
}
/**
* Set pre-get method name.
*
* @param name member method name to be called before marshalling
*/
public void setPregetName(String name) {
m_preGetName = name;
}
/**
* Get marshaller class name.
*
* @return marshaller class name (or null if none)
*/
public String getMarshallerName() {
return m_marshallerName;
}
/**
* Get marshaller class information. This method is only usable after a
* call to {@link #prevalidate(ValidationContext)}.
*
* @return class information for marshaller (or null if none)
*/
public IClass getMarshaller() {
return m_marshallerClass;
}
/**
* Set marshaller class name.
*
* @param name class name to be used for marshalling
*/
public void setMarshallerName(String name) {
m_marshallerName = name;
}
/**
* Get unmarshaller class name.
*
* @return unmarshaller class name (or null if none)
*/
public String getUnmarshallerName() {
return m_unmarshallerName;
}
/**
* Get unmarshaller class information. This method is only usable after a
* call to {@link #prevalidate(ValidationContext)}.
*
* @return class information for unmarshaller (or null if none)
*/
public IClass getUnmarshaller() {
return m_unmarshallerClass;
}
/**
* Set unmarshaller class name.
*
* @param name class name to be used for unmarshalling
*/
public void setUnmarshallerName(String name) {
m_unmarshallerName = name;
}
/**
* Check if nillable object.
*
* @return nillable flag
*/
public boolean isNillable() {
return m_isNillable;
}
/**
* Set nillable flag.
*
* @param nillable flag
*/
public void setNillable(boolean nillable) {
m_isNillable = nillable;
}
/**
* Get type to be used for creating new instance.
*
* @return class name for type to be created (or null if none)
*/
public String getCreateType() {
return m_createType;
}
/**
* Get new instance creation class information. This method is only usable
* after a call to {@link #prevalidate(ValidationContext)}.
*
* @return class information for type to be created (or null if
* none)
*/
public IClass getCreateClass() {
return m_createClass;
}
/**
* Set new instance type class name.
*
* @param name class name to be used for creating new instance
*/
public void setCreateType(String name) {
m_createType = name;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.AttributeBase#prevalidate(org.jibx.binding.model.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// first check for actual object association
IClass iclas;
ElementBase element = vctx.getParentElement(0);
if (element instanceof StructureElementBase) {
if (!((StructureElementBase)element).hasObject()) {
if (m_factoryName != null) {
vctx.addWarning("No object for structure; factory attribute ignored");
m_factoryName = null;
}
if (m_preSetName != null) {
vctx.addWarning("No object for structure; pre-set attribute ignored");
m_preSetName = null;
}
if (m_preGetName != null) {
vctx.addWarning("No object for structure; pre-get attribute ignored");
m_preGetName = null;
}
if (m_postSetName != null) {
vctx.addWarning("No object for structure; post-set attribute ignored");
m_postSetName = null;
}
if (m_marshallerName != null) {
vctx.addWarning("No object for structure; marshaller attribute ignored");
m_marshallerName = null;
}
if (m_unmarshallerName != null) {
vctx.addWarning("No object for structure; unmarshaller attribute ignored");
m_unmarshallerName = null;
}
if (m_createType != null) {
vctx.addWarning("No object for structure; create-type attribute ignored");
m_createType = null;
}
if (m_isNillable) {
vctx.addError("No object for structure; nillable attribute forbidden");
m_isNillable = false;
}
return;
} else {
iclas = ((StructureElementBase)element).getType();
}
} else if (element instanceof MappingElementBase) {
iclas = ((MappingElementBase)element).getHandledClass();
} else {
throw new IllegalStateException
("Unknown element for object attributes");
}
String type = iclas.getName();
// first check for marshaller and unmarshaller classes
if (m_marshallerName != null) {
if (vctx.isOutBinding()) {
IClass mclas = vctx.getClassInfo(m_marshallerName);
if (mclas == null) {
vctx.addError("Marshaller class " + m_marshallerName + " not found");
} else if (vctx.isLookupSupported() && !mclas.isImplements(MARSHALLER_INTERFACETYPE)) {
vctx.addError("Marshaller class " + m_marshallerName + " does not implement interface " + MARSHALLER_INTERFACE);
} else {
m_marshallerClass = mclas;
}
} else {
vctx.addWarning("marshaller attribute ignored for input-only binding");
}
}
if (m_unmarshallerName != null) {
if (vctx.isInBinding()) {
// get the unmarshaller information
IClass uclas = vctx.getClassInfo(m_unmarshallerName);
if (uclas == null) {
vctx.addError("Unmarshaller class " + m_unmarshallerName + " not found");
} else if (vctx.isLookupSupported() && !uclas.isImplements(UNMARSHALLER_INTERFACETYPE)) {
vctx.addError("Unmarshaller class " + m_unmarshallerName + " does not implement interface " + UNMARSHALLER_INTERFACE);
} else {
m_unmarshallerClass = uclas;
}
// check for incompatible attributes
if (m_factoryName != null) {
vctx.addWarning("unmarshaller supplied, factory attribute ignored");
m_factoryName = null;
}
if (m_createType != null) {
vctx.addWarning
("unmarshaller supplied, create-type attribute ignored");
m_createType = null;
}
} else {
vctx.addWarning("unmarshaller attribute ignored for output-only binding");
}
}
// make sure both are supplied if either is supplied
if (vctx.isInBinding() && vctx.isOutBinding()) {
if (m_unmarshallerName != null && m_marshallerName == null) {
vctx.addError("Marshaller is required if unmarshaller is supplied");
} else if (m_marshallerName != null && m_unmarshallerName == null) {
vctx.addError("Unmarshaller is required if marshaller is supplied");
}
}
// next check for factory supplied
if (m_factoryName != null) {
if (vctx.isInBinding()) {
if (vctx.isLookupSupported()) {
// find factory method and verify signature
m_factoryItem = ClassUtils.findStaticMethod(m_factoryName,
FACTORY_HOOK_SIGNATURES, vctx);
if (m_factoryItem == null) {
if (m_factoryName.indexOf('.') > 0) {
vctx.addError("Static factory method " + m_factoryName + " not found");
} else {
vctx.addError("Need class name for static method " + m_factoryName);
}
} else {
String ftype = m_factoryItem.getTypeName();
if (!ClassUtils.isAssignable(ftype, type, vctx) &&
!ClassUtils.isAssignable(type, ftype, vctx))
vctx.addError("Static factory method " + m_factoryName + " return type is not compatible with " + type);
}
}
// check for incompatible attributes
if (m_createType != null) {
vctx.addWarning("unmarshaller supplied, create-type attribute ignored");
m_createType = null;
}
} else {
vctx.addWarning("factory attribute ignored for output-only binding");
}
}
// check for create-type attribute
if (m_createType != null) {
if (vctx.isInBinding()) {
// find create type class and verify compatibility
m_createClass = vctx.getClassInfo(m_createType);
if (m_createClass == null) {
vctx.addError("create-type class " + m_createType + " not found");
} else if (vctx.isLookupSupported()) {
if (!ClassUtils.isAssignable(m_createType, type, vctx) &&
!ClassUtils.isAssignable(type, m_createType, vctx))
vctx.addError("create-type " + m_createType + " is not compatible with expected type " + type);
}
} else {
vctx.addWarning
("create-type attribute ignored for output-only binding");
}
}
// handle pre-set, post-set, and pre-get methods
if (vctx.isLookupSupported()) {
if (vctx.isInBinding()) {
if (m_preSetName != null) {
m_preSetItem = iclas.getMethod(m_preSetName,
UNMARSHAL_HOOK_SIGNATURES);
if (m_preSetItem == null) {
vctx.addError("Nonstatic pre-set method " + m_preSetName + " not found");
}
}
if (m_postSetName != null) {
m_postSetItem = iclas.getMethod(m_postSetName,
UNMARSHAL_HOOK_SIGNATURES);
if (m_postSetItem == null) {
vctx.addError("Nonstatic post-set method " + m_postSetName + " not found");
}
}
}
if (vctx.isOutBinding()) {
if (m_preGetName != null) {
m_preGetItem = iclas.getMethod(m_preGetName,
MARSHAL_HOOK_SIGNATURES);
if (m_preGetItem == null) {
vctx.addError("Nonstatic pre-get method " + m_preGetName + " not found");
}
}
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/PrecompiledMappingElement.java 0000644 0001750 0001750 00000004536 11027507050 030322 0 ustar twerner twerner /*
Copyright (c) 2008, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.util.ArrayList;
/**
* Model component for mapping element of precompiled binding definition.
*
* @author Dennis M. Sosnoski
*/
public class PrecompiledMappingElement extends MappingElementBase
{
/**
* Default constructor.
*/
public PrecompiledMappingElement() {
super(MAPPING_ELEMENT);
m_topChildren = new ArrayList();
}
/**
* Add top-level child element. This override of the
* {@link TemplateElementBase} method discards everything except for
* namespace elements, which may be required in order to determine
* the namespace URI for a concrete mapping.
*
* @param child element to be added as child of this element
*/
public void addTopChild(Object child) {
if (child instanceof NamespaceElement) {
super.addTopChild(child);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/FormatElement.java 0000644 0001750 0001750 00000025474 11072762652 026012 0 ustar twerner twerner /*
Copyright (c) 2004-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
import org.jibx.util.StringArray;
/**
* Model component for format element. This element defines conversion to
* and from simple unstructured text representations.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class FormatElement extends ElementBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "label", "type" },
StringAttributes.s_allowedAttributes);
/** Format label. */
private String m_label;
/** Format qualified name. */
private QName m_qname;
/** Default format for type flag. */
private boolean m_isDefault;
/** Name of value type. */
private String m_typeName;
/** Value type information. */
private IClass m_type;
/** String attributes information for value. */
private StringAttributes m_stringAttrs;
/**
* Constructor.
*/
public FormatElement() {
super(FORMAT_ELEMENT);
m_stringAttrs = new StringAttributes();
}
/**
* Get format label.
*
* @return format label (null if none)
*/
public String getLabel() {
return m_label;
}
/**
* Set format label. This method changes the qualified name to match the
* label.
*
* @param label format label (null if none)
*/
public void setLabel(String label) {
m_label = label;
m_qname = (label == null) ? null : new QName(label);
}
/**
* Get format qualified name.
*
* @return format qualified name (null if none)
*/
public QName getQName() {
return m_qname;
}
/**
* Set format qualified name. This method changes the label value to match
* the qualified name.
*
* @param qname format qualified name (null if none)
*/
public void setQName(QName qname) {
m_qname = qname;
m_label = (qname == null) ? null : qname.toString();
}
/**
* Check if default format for type.
*
* @return true if default for type, false if not
*/
public boolean isDefaultFormat() {
return m_isDefault;
}
/**
* Set default format for type.
*
* @param dflt true if default for type, false if
* not
*/
public void setDefaultFormat(boolean dflt) {
m_isDefault = dflt;
}
/**
* Get value type. This method is only usable after a
* call to {@link #validate}.
*
* @return default value object
*/
public IClass getType() {
return m_type;
}
/**
* Get value type name.
*
* @return value type name
*/
public String getTypeName() {
return m_typeName;
}
/**
* Set value type name.
*
* @param value type name
*/
public void setTypeName(String value) {
m_typeName = value;
}
//
// String attribute delegate methods
/**
* Get default value text.
*
* @return default value text
*/
public String getDefaultText() {
return m_stringAttrs.getDefaultText();
}
/**
* Get default value. This call is only meaningful after validation.
*
* @return default value object
*/
public Object getDefault() {
return m_stringAttrs.getDefault();
}
/**
* Set default value text.
*
* @param value default value text
*/
public void setDefaultText(String value) {
m_stringAttrs.setDefaultText(value);
}
/**
* Get enum value method information. This method is only usable after a
* call to {@link #validate(ValidationContext)}.
*
* @return enum value method information (or null if none)
*/
public IClassItem getEnumValue() {
return m_stringAttrs.getEnumValue();
}
/**
* Get enum value method name.
*
* @return enum value method name (or null if none)
*/
public String getEnumValueName() {
return m_stringAttrs.getEnumValueName();
}
/**
* Set enum value method name.
*
* @param name enum value method name (null if none)
*/
public void setEnumValueName(String name) {
m_stringAttrs.setEnumValueName(name);
}
/**
* Get serializer name.
*
* @return fully qualified class and method name for serializer (or
* null if none)
*/
public String getSerializerName() {
return m_stringAttrs.getSerializerName();
}
/**
* Get serializer method information. This call is only meaningful after
* validation.
*
* @return serializer information (or null if none)
*/
public IClassItem getSerializer() {
return m_stringAttrs.getSerializer();
}
/**
* Set serializer method name.
*
* @param name fully qualified class and method name for serializer
*/
public void setSerializerName(String name) {
m_stringAttrs.setSerializerName(name);
}
/**
* Get deserializer name.
*
* @return fully qualified class and method name for deserializer (or
* null if none)
*/
public String getDeserializerName() {
return m_stringAttrs.getDeserializerName();
}
/**
* Get deserializer method information. This call is only meaningful after
* validation.
*
* @return deserializer information (or null if none)
*/
public IClassItem getDeserializer() {
return m_stringAttrs.getDeserializer();
}
/**
* Set deserializer method name.
*
* @param name fully qualified class and method name for deserializer
*/
public void setDeserializerName(String name) {
m_stringAttrs.setDeserializerName(name);
}
/**
* Get base format information. This method is only usable after a
* call to {@link #validate}.
*
* @return base format element (or null if none)
*/
public FormatElement getBaseFormat() {
return m_stringAttrs.getBaseFormat();
}
//
// Validation methods
/**
* JiBX access method to set format label as qualified name.
*
* @param label format label text (null if none)
* @param ictx unmarshalling context
* @throws JiBXException on deserialization error
*/
private void setQualifiedLabel(String label, IUnmarshallingContext ictx)
throws JiBXException {
setQName(QName.deserialize(label, ictx));
}
/**
* JiBX access method to get format label as qualified name.
*
* @param ictx marshalling context
* @return format label text (null if none)
* @throws JiBXException on deserialization error
*/
private String getQualifiedLabel(IMarshallingContext ictx)
throws JiBXException {
return QName.serialize(getQName(), ictx);
}
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
* @exception JiBXException on unmarshalling error
*/
private void preSet(IUnmarshallingContext uctx) throws JiBXException {
validateAttributes(uctx, s_allowedAttributes);
}
/**
* Set default flag based on whether name supplied or not.
* TODO: use explicit flag for 2.0
*/
private void postSet() {
m_isDefault = m_label == null;
}
/**
* Prevalidate attributes of element in isolation. Note that this adds the
* format information to the context, which is necessary because the string
* attributes for values need to have access to the format information for
* their own prevalidation. This is the only type of registration which is
* done during the prevalidation pass.
*
* @param vctx validation context
*/
public void prevalidate(ValidationContext vctx) {
// prevalidate this format
if (m_typeName != null) {
m_type = vctx.getClassInfo(m_typeName);
if (m_type != null) {
// set the type information
m_stringAttrs.setType(m_type);
m_stringAttrs.prevalidate(vctx);
// now add to context (except when run during setup; kludgy)
if (vctx.getParentElement() != null) {
vctx.getFormatDefinitions().addFormat(this, vctx);
}
} else {
vctx.addFatal("Unable to find type " + m_typeName);
}
} else {
vctx.addFatal("Missing required type name");
}
super.prevalidate(vctx);
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#validate(org.jibx.binding.model.ValidationContext)
*/
public void validate(ValidationContext vctx) {
m_stringAttrs.validate(vctx);
super.validate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/NamespaceElement.java 0000644 0001750 0001750 00000012712 11155422320 026430 0 ustar twerner twerner /*
Copyright (c) 2004-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.util.StringArray;
/**
* Model component for namespace element of binding definition.
*
* @author Dennis M. Sosnoski
*/
public class NamespaceElement extends ElementBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "default", "prefix", "uri" });
//
// Enumeration for namespace usage.
public static final int NODEFAULT_USAGE = 0;
public static final int ELEMENTS_USAGE = 1;
public static final int ATTRIBUTES_USAGE = 2;
public static final int ALLDEFAULT_USAGE = 3;
public static final EnumSet s_defaultEnum =
new EnumSet(NODEFAULT_USAGE,
new String[] { "none", "elements", "attributes", "all" });
//
// Actual instance data
/** Default type name. */
private String m_defaultName = s_defaultEnum.getName(NODEFAULT_USAGE);
/** Actual selected default. */
private int m_defaultIndex;
/** Namespace URI. */
private String m_uri;
/** Namespace prefix (may be null, but not ""). */
private String m_prefix;
/**
* Constructor.
*/
public NamespaceElement() {
super(NAMESPACE_ELEMENT);
}
/**
* Get prefix.
*
* @return prefix text
*/
public String getPrefix() {
return m_prefix;
}
/**
* Set prefix.
*
* @param text prefix text
*/
public void setPrefix(String text) {
m_prefix = text;
}
/**
* Get namespace URI.
*
* @return namespace URI (null if no-namespace namespace)
*/
public String getUri() {
return m_uri;
}
/**
* Set namespace URI.
*
* @param uri namespace URI (null if no-namespace namespace)
*/
public void setUri(String uri) {
m_uri = uri;
}
/**
* Set namespace default type name.
*
* @param name namespace default type
*/
public void setDefaultName(String name) {
m_defaultName = name;
}
/**
* Get namespace default type name.
*
* @return namespace default type name
*/
public String getDefaultName() {
return m_defaultName;
}
/**
* Check if default namespace for attributes. This method is only meaningful
* after a call to {@link #prevalidate(ValidationContext)}.
*
* @return true if default namespace for attributes,
* false if not
*/
public boolean isAttributeDefault() {
return m_defaultIndex == ATTRIBUTES_USAGE ||
m_defaultIndex == ALLDEFAULT_USAGE;
}
/**
* Check if default namespace for elements. This method is only meaningful
* after a call to {@link #prevalidate(ValidationContext)}.
*
* @return true if default namespace for elements,
* false if not
*/
public boolean isElementDefault() {
return m_defaultIndex == ELEMENTS_USAGE ||
m_defaultIndex == ALLDEFAULT_USAGE;
}
//
// Validation methods
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
*/
private void preSet(IUnmarshallingContext uctx) {
validateAttributes(uctx, s_allowedAttributes);
}
/**
* Prevalidate attributes of element in isolation.
*
* @param vctx validation context
*/
public void prevalidate(ValidationContext vctx) {
m_defaultIndex = s_defaultEnum.getValue(m_defaultName);
if (m_defaultIndex < 0) {
vctx.addError("Value \"" + m_defaultName +
"\" is not a valid choice for namespace default usage");
} else if (m_prefix == null && m_uri != null && vctx.isOutBinding() &&
m_defaultIndex != ELEMENTS_USAGE) {
vctx.addError("Prefix required for namespace on output binding unless default='elements' used");
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/ClassItemWrapper.java 0000644 0001750 0001750 00000013132 11062041104 026436 0 ustar twerner twerner /*
Copyright (c) 2004-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import org.jibx.binding.classes.ClassItem;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
/**
* Wrapper for class field or method item information. This wraps the BCEL-based
* class handling implementation to support the interface defined for use with
* the binding model.
*
* @author Dennis M. Sosnoski
*/
public class ClassItemWrapper implements IClassItem
{
private final IClass m_class;
private final ClassItem m_item;
/**
* Constructor.
*
* @param clas
* @param item
*/
protected ClassItemWrapper(IClass clas, ClassItem item) {
m_class = clas;
m_item = item;
}
/**
* Get containing class information.
*
* @return class information
*/
protected IClass getContainingClass() {
return m_class;
}
/**
* Get class item information.
*
* @return item information
*/
protected ClassItem getClassItem() {
return m_item;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#getOwningClass()
*/
public IClass getOwningClass() {
return m_class;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#getName()
*/
public String getName() {
return m_item.getName();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#getJavaDoc()
*/
public String getJavaDoc() {
return null;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#getType()
*/
public String getTypeName() {
return m_item.getTypeName();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#getReturnJavaDoc()
*/
public String getReturnJavaDoc() {
if (m_item.isMethod()) {
return null;
} else {
throw new IllegalStateException("Internal error: not a method");
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#getArgumentCount()
*/
public int getArgumentCount() {
return m_item.getArgumentCount();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#getArgumentType(int)
*/
public String getArgumentType(int index) {
return m_item.getArgumentTypes()[index];
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#getParameterJavaDoc(int)
*/
public String getParameterJavaDoc(int index) {
if (m_item.isMethod()) {
return null;
} else {
throw new IllegalStateException("Internal error: not a method");
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#getParameterName(int)
*/
public String getParameterName(int index) {
return m_item.getParameterName(index);
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#getAccessFlags()
*/
public int getAccessFlags() {
return m_item.getAccessFlags();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#getSignature()
*/
public String getSignature() {
return m_item.getSignature();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#isMethod()
*/
public boolean isMethod() {
return m_item.isMethod();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#isInitializer()
*/
public boolean isInitializer() {
return m_item.isInitializer();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#getExceptions()
*/
public String[] getExceptions() {
return m_item.getExceptions();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#getExceptionJavaDoc(int)
*/
public String getExceptionJavaDoc(int index) {
if (m_item.isMethod()) {
return null;
} else {
throw new IllegalStateException("Internal error: not a method");
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IClassItem#getGenericsSignature()
*/
public String getGenericsSignature() {
return m_item.getGenericsSignature();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/BindingElement.java 0000644 0001750 0001750 00000107604 11424505122 026114 0 ustar twerner twerner /*
Copyright (c) 2004-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.jibx.binding.classes.ClassCache;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IUnmarshallable;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.IXMLWriter;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.Utility;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.util.IClass;
import org.jibx.util.StringArray;
/**
* Model component for binding element.
*
* @author Dennis M. Sosnoski
*/
public class BindingElement extends NestingElementBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "add-constructors", "direction",
"force-classes", "forwards", "name", "package", "track-source",
"trim-whitespace" }, NestingElementBase.s_allowedAttributes);
//
// Value set information
public static final int IN_BINDING = 0;
public static final int OUT_BINDING = 1;
public static final int BOTH_BINDING = 2;
/*package*/ static final EnumSet s_directionEnum = new EnumSet(IN_BINDING,
new String[] { "input", "output", "both" });
//
// Instance data
/** Binding name. */
private String m_name;
/** Binding direction. */
private String m_direction;
/** Input binding flag. */
private boolean m_inputBinding;
/** Output binding flag. */
private boolean m_outputBinding;
/** Support forward references to IDs flag. */
private boolean m_forwardReferences;
/** Generate souce tracking interface flag. */
private boolean m_trackSource;
/** Generate souce tracking interface flag. */
private boolean m_forceClasses;
/** Add default constructors where needed flag. */
private boolean m_addConstructors;
/** Trim whitespace for simple values (schema compatibility) flag. */
private boolean m_trimWhitespace;
/** Major version of binding. */
private int m_majorVersion;
/** Minor version of binding. */
private int m_minorVersion;
/** Package for generated context factory. */
private String m_targetPackage;
/** Precompiled binding flag. */
private boolean m_precompiled;
/** Base URL for use with relative include paths. */
private URL m_baseUrl;
/** Set of paths for includes. */
private final Set m_includePaths;
/** Set of paths for precompiled includes. */
private final Set m_precompiledPaths;
/** Map from include path to actual binding. */
private final Map m_includeBindings;
/** List of child elements. */
private final ArrayList m_children;
/** Set of class names which can be referenced by ID. */
private Set m_idClassSet;
/** List of namespace declarations to be added on output (lazy create,
null if none). */
private ArrayList m_namespaceDeclares;
/**
* Default constructor.
*/
public BindingElement() {
super(BINDING_ELEMENT);
m_includePaths = new HashSet();
m_precompiledPaths = new HashSet();
m_includeBindings = new HashMap();
m_children = new ArrayList();
m_forwardReferences = true;
}
/**
* Set binding name.
*
* @param name binding definition name
*/
public void setName(String name) {
m_name = name;
}
/**
* Get binding name.
*
* @return binding definition name
*/
public String getName() {
return m_name;
}
/**
* Set forward references to IDs be supported in XML.
*
* @param forward true if forward references supported,
* false if not
*/
public void setForward(boolean forward) {
m_forwardReferences = forward;
}
/**
* Check if forward references to IDs must be supported in XML.
*
* @return true if forward references required,
* false if not
*/
public boolean isForward() {
return m_forwardReferences;
}
/**
* Set source position tracking for unmarshalling.
*
* @param track true if source position tracking enabled,
* false if not
*/
public void setTrackSource(boolean track) {
m_trackSource = track;
}
/**
* Check if source position tracking enabled for unmarshalling.
*
* @return true if source position tracking enabled,
* false if not
*/
public boolean isTrackSource() {
return m_trackSource;
}
/**
* Set force marshaller/unmarshaller class creation for top-level non-base
* abstract mappings.
*
* @param force true if class generation forced,
* false if not
*/
public void setForceClasses(boolean force) {
m_forceClasses = force;
}
/**
* Check if marshaller/unmarshaller class creation for top-level non-base
* abstract mappings is forced.
*
* @return true if class generation forced,
* false if not
*/
public boolean isForceClasses() {
return m_forceClasses;
}
/**
* Set default constructor generation.
*
* @param add true if constructors should be added,
* false if not
*/
public void setAddConstructors(boolean add) {
m_addConstructors = add;
}
/**
* Check if default constructor generation is enabled.
*
* @return true if default constructor generation enabled,
* false if not
*/
public boolean isAddConstructors() {
return m_addConstructors;
}
/**
* Set trim whitespace flag.
*
* @param trim true if whitespace should be trimmed from simple
* values, false if not
*/
public void setTrimWhitespace(boolean trim) {
m_trimWhitespace = trim;
}
/**
* Check if whitespace should be trimmed from simple values.
*
* @return trim whitespace flag
*/
public boolean isTrimWhitespace() {
return m_trimWhitespace;
}
/**
* Get major version number.
*
* @return major version
*/
public int getMajorVersion() {
return m_majorVersion;
}
/**
* Set major version number.
*
* @param ver major version
*/
public void setMajorVersion(int ver) {
m_majorVersion = ver;
}
/**
* Get minor version number.
*
* @return minor version
*/
public int getMinorVersion() {
return m_minorVersion;
}
/**
* Set minor version number.
*
* @param ver minor version
*/
public void setMinorVersion(int ver) {
m_minorVersion = ver;
}
/**
* Set package for generated context factory class.
*
* @param pack generated context factory package (null if
* unspecified)
*/
public void setTargetPackage(String pack) {
m_targetPackage = pack;
}
/**
* Get package for generated context factory class.
*
* @return package for generated context factory (null if
* unspecified)
*/
public String getTargetPackage() {
return m_targetPackage;
}
/**
* Set base URL for relative include paths.
*
* @param base
*/
public void setBaseUrl(URL base) {
m_baseUrl = base;
}
/**
* Get base URL for relative include paths.
*
* @return base URL
*/
public URL getBaseUrl() {
return m_baseUrl;
}
/**
* Set the correct direction text. This should be used whenever the
* individual in and out flags are set, so that modifications are output
* correctly when a binding is marshalled.
*/
private void setDirection() {
int direct = m_inputBinding ? (m_outputBinding ? BOTH_BINDING : IN_BINDING) :
OUT_BINDING;
m_direction = s_directionEnum.getName(direct);
}
/**
* Set binding component applies for marshalling XML.
*
* @param out true if binding supports output,
* false if not
*/
public void setOutBinding(boolean out) {
m_outputBinding = out;
setDirection();
}
/**
* Check if this binding component applies for marshalling XML.
*
* @return true if binding supports output, false
* if not
*/
public boolean isOutBinding() {
return m_outputBinding;
}
/**
* Set binding component applies for unmarshalling XML.
*
* @param in true if binding supports input,
* false if not
*/
public void setInBinding(boolean in) {
m_inputBinding = in;
setDirection();
}
/**
* Check if this binding component applies for unmarshalling XML.
*
* @return true if binding supports input, false
* if not
*/
public boolean isInBinding() {
return m_inputBinding;
}
/**
* Check if a precompiled binding.
*
* @return true if precompiled, false if not
*/
public boolean isPrecompiled() {
return m_precompiled;
}
/**
* Set precompiled binding flag.
*
* @param precomp
*/
public void setPrecompiled(boolean precomp) {
m_precompiled = precomp;
}
/**
* Add include path to set processed.
*
* @param path
* @param precomp precompiled binding flag
* @return true if new path, false if duplicate
*/
public boolean addIncludePath(String path, boolean precomp) {
if (m_includePaths.add(path)) {
if (precomp || m_precompiled) {
m_precompiledPaths.add(path);
}
return true;
} else {
return false;
}
}
/**
* Get included binding. If the binding was supplied directly it's just
* returned; otherwise, it's read from the URL. This method should only be
* called if {@link #addIncludePath(String, boolean)} returns
* true, so that each unique included binding is only processed
* once.
*
* @param url binding path
* @param root binding containing the include
* @param vctx validation context
* @return binding
* @throws IOException
* @throws JiBXException
*/
public BindingElement getIncludeBinding(URL url, BindingElement root,
ValidationContext vctx) throws IOException, JiBXException {
String path = url.toExternalForm();
BindingElement bind = (BindingElement)m_includeBindings.get(path);
if (bind == null) {
// get base name from path
path = path.replace('\\', '/');
int split = path.lastIndexOf('/');
String fname = path;
if (split >= 0) {
fname = fname.substring(split+1);
}
// read stream to create object model
InputStream is = url.openStream();
bind = readBinding(is, fname, root,
m_precompiledPaths.contains(path), vctx);
}
// set binding base, and context from root context
bind.setBaseUrl(url);
bind.setDefinitions(root.getDefinitions().getIncludeCopy());
m_includeBindings.put(path, bind);
return bind;
}
/**
* Get existing included binding.
*
* @param url binding path
* @return binding if it exists, otherwise null
*/
public BindingElement getExistingIncludeBinding(URL url) {
return (BindingElement)m_includeBindings.get(url.toExternalForm());
}
/**
* Add binding accessible to includes. This allows bindings to be supplied
* directly, without needing to be parsed from an input document.
*
* @param path URL string identifying the binding (virtual path)
* @param bind
*/
public void addIncludeBinding(String path, BindingElement bind) {
if (addIncludePath(path, false)) {
m_includeBindings.put(path, bind);
}
}
/**
* Add a class defined with a ID value. This is used to track the classes
* with ID values for validating ID references in the binding. If the
* binding uses global IDs, the actual ID class is added to the table along
* with all interfaces implemented by the class and all superclasses, since
* instances of the ID class can be referenced in any of those forms. If the
* binding does not use global IDs, only the actual ID class is added, since
* references must be type-specific.
*
* @param clas information for class with ID value
*/
public void addIdClass(IClass clas) {
// create the set if not already present
if (m_idClassSet == null) {
m_idClassSet = new HashSet();
}
// add the class if not already present
if (m_idClassSet.add(clas.getName())) {
// new class, add all interfaces if not previously defined
String[] inames = clas.getInterfaces();
for (int i = 0; i < inames.length; i++) {
m_idClassSet.add(inames[i]);
}
while (clas != null && m_idClassSet.add(clas.getName())) {
clas = clas.getSuperClass();
}
}
}
/**
* Check if a class can be referenced by ID. This just checks if any classes
* compatible with the reference type are bound with ID values.
*
* @param name fully qualified name of class
* @return true if class is bound with an ID,
* false if not
*/
public boolean isIdClass(String name) {
if (m_idClassSet == null) {
return false;
} else {
return m_idClassSet.contains(name);
}
}
/**
* Add top-level child element.
* TODO: should be ElementBase argument, but JiBX doesn't allow yet
*
* @param child element to be added as child of this element
*/
public void addTopChild(Object child) {
m_children.add(child);
}
/**
* Get list of top-level child elements.
*
* @return list of child elements, or null if none
*/
public ArrayList topChildren() {
return m_children;
}
/**
* Get iterator for top-level child elements.
*
* @return iterator for child elements
*/
public Iterator topChildIterator() {
return m_children.iterator();
}
/**
* Add namespace declaration for output when marshalling.
*
* @param prefix namespace prefix (null if none)
* @param uri namespace URI (non-null)
*/
public void addNamespaceDecl(String prefix, String uri) {
if (uri == null) {
throw new IllegalArgumentException("Internal error - namespace URI cannot be null");
}
if (m_namespaceDeclares == null) {
m_namespaceDeclares = new ArrayList();
}
m_namespaceDeclares.add(prefix == null ? "" : prefix);
m_namespaceDeclares.add(uri);
}
//
// Overrides of base class methods.
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#hasAttribute()
*/
public boolean hasAttribute() {
throw new IllegalStateException
("Internal error: method should never be called");
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#hasContent()
*/
public boolean hasContent() {
throw new IllegalStateException
("Internal error: method should never be called");
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#isOptional()
*/
public boolean isOptional() {
throw new IllegalStateException
("Internal error: method should never be called");
}
/**
* Get default style value for child components. This call is only
* meaningful after validation.
*
* @return default style value for child components
*/
public int getDefaultStyle() {
int style = super.getDefaultStyle();
if (style < 0) {
style = NestingAttributes.s_styleEnum.getValue("element");
}
return style;
}
//
// Marshalling/unmarshalling methods
/**
* Marshalling hook method to add namespace declarations to <binding>
* element.
*
* @param ictx
* @throws IOException
*/
private void preGet(IMarshallingContext ictx) throws IOException {
if (m_namespaceDeclares != null) {
// set up information for namespace indexes and prefixes
IXMLWriter writer = ictx.getXmlWriter();
String[] uris = new String[m_namespaceDeclares.size()/2];
int[] indexes = new int[uris.length];
String[] prefs = new String[uris.length];
int base = writer.getNamespaceCount();
for (int i = 0; i < uris.length; i++) {
indexes[i] = base + i;
prefs[i] = (String)m_namespaceDeclares.get(i*2);
uris[i] = (String)m_namespaceDeclares.get(i*2+1);
}
// add the namespace declarations to current element
writer.pushExtensionNamespaces(uris);
writer.openNamespaces(indexes, prefs);
for (int i = 0; i < uris.length; i++) {
String prefix = prefs[i];
String name = prefix.length() == 0 ?
"xmlns" : "xmlns:" + prefix;
writer.addAttribute(0, name, uris[i]);
}
}
}
//
// Validation methods
/**
* Make sure all attributes are defined.
*
* @param ictx unmarshalling context
* @exception JiBXException on unmarshalling error
*/
private void preSet(IUnmarshallingContext ictx) throws JiBXException {
// validate the attributes defined for this element
validateAttributes(ictx, s_allowedAttributes);
// get the unmarshal wrapper
UnmarshalWrapper wrapper =
(UnmarshalWrapper)ictx.getStackObject(ictx.getStackDepth()-1);
if (wrapper.getContainingBinding() != null) {
// check attributes not allowed on included binding
BindingElement root = wrapper.getContainingBinding();
ValidationContext vctx = wrapper.getValidation();
UnmarshallingContext uctx = (UnmarshallingContext)ictx;
for (int i = 0; i < uctx.getAttributeCount(); i++) {
// check if nonamespace attribute is in the allowed set
String name = uctx.getAttributeName(i);
if (uctx.getAttributeNamespace(i).length() == 0) {
if (s_allowedAttributes.indexOf(name) >= 0) {
String value = uctx.getAttributeValue(i);
if ("direction".equals(name)) {
if (m_precompiled) {
boolean compat = true;
if (root.m_direction == null ||
"both".equals(root.m_direction)) {
compat = value.equals("both");
} else if ("input".equals(root.m_direction)) {
compat = !value.equals("output");
} else if ("output".equals(root.m_direction)) {
compat = !value.equals("input");
}
if (!compat) {
vctx.addError("'direction' value on included precompiled binding is incompatible with root binding",
this);
}
} else if (!value.equals(root.m_direction)) {
vctx.addError("'direction' value on included binding must match the root binding",
this);
}
} else if ("track-source".equals(name)) {
if (!m_precompiled) {
boolean flag = Utility.parseBoolean(value);
if (root.m_trackSource != flag) {
vctx.addError("'track-source' value on included binding must match the root binding",
this);
}
}
} else if ("value-style".equals(name)) {
if (!m_precompiled) {
if (!value.equals(root.getStyleName())) {
vctx.addError("'value-style' value on included binding must match the root binding",
this);
}
}
} else if ("force-classes".equals(name)) {
if (!m_precompiled) {
boolean flag = Utility.parseBoolean(value);
if (root.m_forceClasses != flag) {
vctx.addError("'force-classes' value on included binding must match the root binding",
this);
}
}
} else if ("add-constructors".equals(name)) {
if (!m_precompiled) {
boolean flag = Utility.parseBoolean(value);
if (root.m_addConstructors != flag) {
vctx.addError("'add-constructors' value on included binding must match the root binding",
this);
}
}
} else if ("forwards".equals(name)) {
if (!m_precompiled) {
boolean flag = Utility.parseBoolean(value);
if (root.m_forwardReferences != flag) {
vctx.addError("'forwards' value on included binding must match the root binding",
this);
}
}
} else if ("trim-whitespace".equals(name)) {
if (!m_precompiled) {
boolean flag = Utility.parseBoolean(value);
if (root.m_trimWhitespace != flag) {
vctx.addError("'trim-whitespace' value on included binding must match the root binding",
this);
}
}
} else if (!"package".equals(name) && !"name".equals(name)) {
vctx.addError("Attribute '" + name + "' not allowed on included binding",
this);
}
}
}
}
}
}
/**
* Prevalidate all attributes of element in isolation.
*
* @param vctx validation context
*/
public void prevalidate(ValidationContext vctx) {
// set the direction flags
int index = -1;
if (m_direction != null) {
index = s_directionEnum.getValue(m_direction);
if (index < 0) {
vctx.addError("Value \"" + m_direction +
"\" is not a valid choice for direction");
}
} else {
index = BOTH_BINDING;
}
m_inputBinding = index == IN_BINDING || index == BOTH_BINDING;
m_outputBinding = index == OUT_BINDING || index == BOTH_BINDING;
// check for illegal characters in name
if (m_name != null) {
int length = m_name.length();
for (int i = 0; i < length; i++) {
if (!Character.isJavaIdentifierPart(m_name.charAt(i))) {
vctx.addError("Binding name '" + m_name +
" contains invalid characters (only Java identifier part characters allowed)",
this);
break;
}
}
}
super.prevalidate(vctx);
}
private static FormatElement buildFormat(String name, String type,
boolean use, String sname, String dname, String dflt) {
FormatElement format = new FormatElement();
format.setLabel(name);
format.setTypeName(type);
format.setDefaultFormat(use);
format.setSerializerName(sname);
format.setDeserializerName(dname);
format.setDefaultText(dflt);
return format;
}
/**
* Define a built-in format. This checks to make sure the type referenced by
* the format is present in the classpath, since some of the build-in
* formats apply to classes which are not part of the required runtime.
*
* @param format
* @param dctx
* @param vctx
*/
private void defineBaseFormat(FormatElement format, DefinitionContext dctx,
ValidationContext vctx) {
if (vctx.getClassInfo(format.getTypeName()) != null) {
format.prevalidate(vctx);
format.validate(vctx);
dctx.addFormat(format, vctx);
}
}
/**
* Run the actual validation of a binding model. This allows either partial
* or full validation, with partial validation not requiring access to class
* files.
*
* @param full run full validation flag (requires access to class files)
* @param vctx context for controlling validation
*/
public void runValidation(boolean full, ValidationContext vctx) {
// initially enable both directions for format setup
m_inputBinding = true;
m_outputBinding = true;
// create outer definition context
DefinitionContext dctx = new DefinitionContext(null);
vctx.setGlobalDefinitions(dctx);
for (int i = 0; i < BuiltinFormats.s_builtinFormats.length; i++) {
defineBaseFormat(BuiltinFormats.s_builtinFormats[i], dctx, vctx);
}
FormatElement format = buildFormat("char.string", "char", false,
"org.jibx.runtime.Utility.serializeCharString",
"org.jibx.runtime.Utility.deserializeCharString", "0");
format.setDefaultFormat(false);
format.prevalidate(vctx);
format.validate(vctx);
dctx.addFormat(format, vctx);
NamespaceElement ns = new NamespaceElement();
ns.setDefaultName("all");
ns.prevalidate(vctx);
dctx.addNamespace(ns);
// TODO: check for errors in basic configuration
// create a definition context for the binding
setDefinitions(new DefinitionContext(dctx));
// run the actual validation
vctx.prevalidate(this);
RegistrationVisitor rvisitor = new RegistrationVisitor(vctx);
rvisitor.visitTree(this);
if (full) {
vctx.validate(this);
}
}
/**
* Run the actual validation of a binding model. This form of call always
* does a full validation.
*
* @param vctx context for controlling validation
*/
public void runValidation(ValidationContext vctx) {
runValidation(true, vctx);
}
/**
* Read a binding definition (possibly as an include) to construct binding
* model.
*
* @param is input stream for reading binding
* @param fname name of input file (null if unknown)
* @param contain containing binding (null if none)
* @param precomp precompiled binding flag
* @param vctx validation context used during unmarshalling
* @return root of binding definition model
* @throws JiBXException on error in reading binding
*/
public static BindingElement readBinding(InputStream is, String fname,
BindingElement contain, boolean precomp, ValidationContext vctx) throws JiBXException {
// look up the binding factory
String bindname = precomp ? "precomp" : "normal";
IBindingFactory bfact =
BindingDirectory.getFactory(bindname, "org.jibx.binding.model");
// unmarshal document to construct objects
IUnmarshallingContext uctx = bfact.createUnmarshallingContext();
uctx.setDocument(is, fname, null);
uctx.pushObject(new UnmarshalWrapper(vctx, contain));
BindingElement binding = new BindingElement();
binding.setPrecompiled(precomp);
((IUnmarshallable)binding).unmarshal(uctx);
uctx.popObject();
return binding;
}
/**
* Read a binding definition to construct binding model. This method cannot
* be used for precompiled bindings.
*
* @param is input stream for reading binding
* @param fname name of input file (null if unknown)
* @param vctx validation context used during unmarshalling
* @return root of binding definition model
* @throws JiBXException on error in reading binding
*/
public static BindingElement readBinding(InputStream is, String fname,
ValidationContext vctx) throws JiBXException {
return readBinding(is, fname, null, false, vctx);
}
/**
* Validate a binding definition. This method cannot be used for precompiled
* bindings.
*
* @param name binding definition name
* @param path binding definition URL
* @param is input stream for reading binding
* @param vctx validation context to record problems
* @return root of binding definition model, or null if error
* in unmarshalling
* @throws JiBXException on error in binding XML structure
*/
public static BindingElement validateBinding(String name, URL path,
InputStream is, ValidationContext vctx) throws JiBXException {
// construct object model for binding
BindingElement binding = readBinding(is, name, vctx);
binding.setBaseUrl(path);
vctx.setBindingRoot(binding);
// validate the binding definition
binding.runValidation(vctx);
// list validation errors
ArrayList probs = vctx.getProblems();
if (probs.size() > 0) {
for (int i = 0; i < probs.size(); i++) {
ValidationProblem prob = (ValidationProblem)probs.get(i);
System.out.print(prob.getSeverity() >=
ValidationProblem.ERROR_LEVEL ? "Error: " : "Warning: ");
System.out.println(prob.getDescription());
}
}
return binding;
}
/**
* Create a default validation context.
*
* @return new validation context
*/
public static ValidationContext newValidationContext() {
return new ValidationContext(new ClassCache.ClassCacheLocator());
}
/* // test runner
// This code only used in testing, to roundtrip binding definitions
public static void test(String ipath, String opath, ValidationContext vctx)
throws Exception {
// validate the binding definition
FileInputStream is = new FileInputStream(ipath);
URL url = new URL("file://" + ipath);
BindingElement binding = validateBinding(ipath, url, is, vctx);
// marshal back out for comparison purposes
IBindingFactory bfact =
BindingDirectory.getFactory(BindingElement.class);
IMarshallingContext mctx = bfact.createMarshallingContext();
mctx.setIndent(2);
mctx.marshalDocument(binding, null, null, new FileOutputStream(opath));
System.out.println("Wrote output binding " + opath);
// compare input document with output document
DocumentComparator comp = new DocumentComparator(System.err);
boolean match = comp.compare(new FileReader(ipath),
new FileReader(opath));
if (!match) {
System.err.println("Mismatch from input " + ipath +
" to output " + opath);
}
}
// test runner
public static void main(String[] args) throws Exception {
// configure class loading
String[] paths = new String[] { "." };
ClassCache.setPaths(paths);
ClassFile.setPaths(paths);
ValidationContext vctx = newValidationContext();
// process all bindings listed on command line
for (int i = 0; i < args.length; i++) {
try {
String ipath = args[i];
int split = ipath.lastIndexOf(File.separatorChar);
String opath = "x" + ipath.substring(split+1);
test(ipath, opath, vctx);
} catch (Exception e) {
System.err.println("Error handling binding " + args[i]);
e.printStackTrace();
}
}
} */
/**
* Inner class as wrapper for binding element on unmarshalling. This
* provides a handle for passing the validation context, allowing elements
* to check for problems during unmarshalling.
*/
public static class UnmarshalWrapper
{
private final ValidationContext m_validationContext;
private final BindingElement m_containingBinding;
protected UnmarshalWrapper(ValidationContext vctx,
BindingElement contain) {
m_validationContext = vctx;
m_containingBinding = contain;
}
public ValidationContext getValidation() {
return m_validationContext;
}
public BindingElement getContainingBinding() {
return m_containingBinding;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/OutputElement.java 0000644 0001750 0001750 00000003561 10210703670 026037 0 ustar twerner twerner /*
Copyright (c) 2004-2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
/**
* Model component for output element of binding definition. This is only
* used for structuring purposes and doesn't require any actual processing.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class OutputElement extends NestingElementBase
{
/**
* Constructor.
*/
public OutputElement() {
super(OUTPUT_ELEMENT);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/ValidationContext.java 0000644 0001750 0001750 00000023416 11155421714 026672 0 ustar twerner twerner /*
Copyright (c) 2004-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.util.ArrayList;
import org.jibx.util.IClass;
import org.jibx.util.IClassLocator;
/**
* Tracks the validation state. This includes the current validation phase, as
* well as order-dependent state information collected while walking the tree
* structure of a binding model. Collects all errors and warnings and maintains
* a summary of the severity of the problems found.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class ValidationContext extends TreeContext
{
/** Number of warnings reported. */
private int m_warningCount;
/** Number of errors reported. */
private int m_errorCount;
/** Number of fatals reported. */
private int m_fatalCount;
/** List of problem items reported by validation. */
private ArrayList m_problemList;
/**
* Constructor.
*
* @param iloc class locator
*/
public ValidationContext(IClassLocator iloc) {
super(iloc);
m_problemList = new ArrayList();
}
/**
* Peek current element of hierarchy, if any. This variation should be used
* for the actual error handling, in case an error occurs during the
* initialization of the outer context definitions (canned definitions).
*
* @return current element, or null if none
*/
private ElementBase safePeekElement() {
try {
return peekElement();
} catch (ArrayIndexOutOfBoundsException e) {
// just in case there is no context element
return null;
}
}
/**
* Prevalidate binding model tree. This calls the prevalidate method for
* each element in the tree, in preorder traversal order.
*
* @param root binding node of tree to be prevalidated
*/
public void prevalidate(BindingElement root) {
PrevalidationVisitor visitor = new PrevalidationVisitor();
tourTree(root, visitor);
}
/**
* Validate binding model tree. This calls the validate method for each
* element in the tree, in postorder traversal order.
*
* @param root binding node of tree to be prevalidated
*/
public void validate(BindingElement root) {
ValidationVisitor visitor = new ValidationVisitor();
tourTree(root, visitor);
}
/**
* Get number of warning problems reported.
*
* @return warning problem count
*/
public int getWarningCount() {
return m_warningCount;
}
/**
* Get number of error problems reported.
*
* @return error problem count
*/
public int getErrorCount() {
return m_errorCount;
}
/**
* Get number of fatal problems reported.
*
* @return fatal problem count
*/
public int getFatalCount() {
return m_fatalCount;
}
/**
* Add warning item for current element. Adds a warning item to the problem
* list, which is a possible problem that still allows reasonable operation.
* This form of the call can only be used during a tree tour being
* controlled by this context.
*
* @param msg problem description
*/
public void addWarning(String msg) {
addWarning(msg, safePeekElement());
}
/**
* Add warning item. Adds a warning item to the problem list, which is a
* possible problem that still allows reasonable operation.
*
* @param msg problem description
* @param obj source object for validation error
*/
public void addWarning(String msg, Object obj) {
addProblem(new ValidationProblem
(ValidationProblem.WARNING_LEVEL, msg, obj));
}
/**
* Add error item for current element. Adds an error item to the problem
* list, which is a definite problem that still allows validation to
* proceed. This form of the call can only be used during a tree tour being
* controlled by this context.
*
* @param msg problem description
*/
public void addError(String msg) {
addError(msg, safePeekElement());
}
/**
* Add error item. Adds an error item to the problem list, which is a
* definite problem that still allows validation to proceed.
*
* @param msg problem description
* @param obj source object for validation error
*/
public void addError(String msg, Object obj) {
addProblem(new ValidationProblem
(ValidationProblem.ERROR_LEVEL, msg, obj));
}
/**
* Add fatal item for current element. Adds a fatal item to the problem
* list, which is a severe problem that blocks further validation within the
* tree branch involved. This form of the call can only be used during a
* tree tour being controlled by this context.
*
* @param msg problem description
*/
public void addFatal(String msg) {
addFatal(msg, safePeekElement());
}
/**
* Add fatal item. Adds a fatal item to the problem list, which is a severe
* problem that blocks further validation within the tree branch involved.
* The object associated with a fatal error should always be an element.
*
* @param msg problem description
* @param obj source object for validation error (should be an element)
*/
public void addFatal(String msg, Object obj) {
addProblem(new ValidationProblem
(ValidationProblem.FATAL_LEVEL, msg, obj));
}
/**
* Add problem report. The problem is added and counted as appropriate.
*
* @param problem details of problem report
*/
public void addProblem(ValidationProblem problem) {
m_problemList.add(problem);
switch (problem.getSeverity()) {
case ValidationProblem.ERROR_LEVEL:
m_errorCount++;
break;
case ValidationProblem.FATAL_LEVEL:
m_fatalCount++;
addSkip(problem.getComponent());
break;
case ValidationProblem.WARNING_LEVEL:
m_warningCount++;
break;
}
}
/**
* Get list of problems.
*
* @return problem list
*/
public ArrayList getProblems() {
return m_problemList;
}
/**
* Get class information. Finds a class by name using the class locator
* configured by the environment code. This overrides the base class
* implementation in order to report failures that result in exceptions.
*
* @param name fully-qualified name of class to be found
* @return class information, or null if class not found
*/
public IClass getClassInfo(String name) {
try {
return super.getClassInfo(name);
} catch (Exception e) {
addFatal(e.getMessage());
return null;
}
}
/**
* Inner class for handling prevalidation. This visitor implementation just
* calls the {@link org.jibx.binding.model#prevalidate} method for each
* element visited in preorder.
*/
protected class PrevalidationVisitor extends ModelVisitor
{
/* (non-Javadoc)
* @see org.jibx.binding.model.ModelVisitor#visit(org.jibx.binding.model.ElementBase)
*/
public boolean visit(ElementBase node) {
try {
node.prevalidate(ValidationContext.this);
} catch (Throwable t) {
addFatal("Error during validation: " + t.getMessage());
t.printStackTrace();
return false;
}
return true;
}
}
/**
* Inner class for handling validation. This visitor implementation just
* calls the {@link org.jibx.binding.model#validate} method for each
* element visited in postorder.
*/
protected class ValidationVisitor extends ModelVisitor
{
/* (non-Javadoc)
* @see org.jibx.binding.model.ModelVisitor#exit(org.jibx.binding.model.ElementBase)
*/
public void exit(ElementBase node) {
try {
node.validate(ValidationContext.this);
} catch (Throwable t) {
addFatal("Error during validation: " + t.getMessage());
t.printStackTrace();
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/ValueElement.java 0000644 0001750 0001750 00000060545 11153073224 025622 0 ustar twerner twerner /*
Copyright (c) 2004-2008, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.QName;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
import org.jibx.util.StringArray;
/**
* Model component for value element. This element defines a value that
* can be represented as a simple text string, which may be expressed as an
* attribute, element, or text component of the XML document.
*
* @author Dennis M. Sosnoski
*/
public class ValueElement extends ElementBase implements IComponent
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "constant", "format", "ident",
"nillable", "style" },
new StringArray(new StringArray
(NameAttributes.s_allowedAttributes,
PropertyAttributes.s_allowedAttributes),
StringAttributes.s_allowedAttributes));
//
// Value set information
public static final int CDATA_STYLE = 2;
public static final int TEXT_STYLE = 3;
private static final EnumSet s_styleEnum =
new EnumSet(NestingAttributes.s_styleEnum, CDATA_STYLE,
new String[] { "cdata", "text" });
public static final int NONE_IDENT = 0;
public static final int DEF_IDENT = 1;
public static final int REF_IDENT = 2;
/* public static final int AUTO_IDENT = 3; */
/*package*/ static final EnumSet s_identEnum = new EnumSet(NONE_IDENT,
new String[] { "none", "def", "ref"/*, "auto"*/ });
//
// Instance data
/** Supplied constant value. */
private String m_constantValue;
/** Supplied style name. */
private String m_styleName;
/** Actual selected style. */
private int m_styleIndex;
/** Supplied identity name. */
private String m_identName = s_identEnum.getName(NONE_IDENT);
/** Nillable object flag. */
private boolean m_isNillable;
/** Actual selected identity. */
private int m_identIndex;
/** Name attributes information for value. */
private NameAttributes m_nameAttrs;
/** Property attributes information for value. */
private PropertyAttributes m_propertyAttrs;
/** String attributes information for value. */
private StringAttributes m_stringAttrs;
/**
* Constructor.
*/
public ValueElement() {
super(VALUE_ELEMENT);
m_nameAttrs = new NameAttributes();
m_propertyAttrs = new PropertyAttributes();
m_stringAttrs = new StringAttributes();
}
/**
* Get constant value.
*
* @return constant value, or null if not a constant
*/
public String getConstantValue() {
return m_constantValue;
}
/**
* Set constant value.
*
* @param value constant value, or null if not a constant
*/
public void setConstantValue(String value) {
m_constantValue = value;
}
/**
* Get style string value.
*
* @return style string value
*/
public String getStyleName() {
return m_styleName;
}
/**
* Get style value. This call is only meaningful after validation.
*
* @return style value
*/
public int getStyle() {
return m_styleIndex;
}
/**
* Set style name.
*
* @param name style name (null if to use inherited default)
*/
public void setStyleName(String name) {
m_styleName = name;
}
/**
* Get name for style that applies to this value. This call is only
* meaningful after validation.
*
* @return name for style
*/
public String getEffectiveStyleName() {
return s_styleEnum.getName(m_styleIndex);
}
/**
* Set style that applies to this value. If the specified style is different
* from the nested default it is applied directly, otherwise this value is
* configured to use the default. This method should therefore only be used
* when the nested settings are considered fixed.
* TODO: implement this with parent links
*
* @param style style value
*/
public void setEffectiveStyle(int style) {
m_styleIndex = style;
m_styleName = s_styleEnum.getName(style);
}
/**
* Get identity string value.
*
* @return identity string value
*/
public String getIdentName() {
return m_identName;
}
/**
* Get identity value. This call is only meaningful after validation.
*
* @return identity value
*/
public int getIdent() {
return m_identIndex;
}
/**
* Set identity name.
*
* @param name identity name
*/
public void setIdentName(String name) {
m_identName = name;
}
//
// Name attribute delegate methods
/**
* Get name.
*
* @return name text
*/
public String getName() {
return m_nameAttrs.getName();
}
/**
* Set name.
*
* @param name text for name
*/
public void setName(String name) {
m_nameAttrs.setName(name);
}
/**
* Get specified namespace URI.
*
* @return namespace URI (null if not set)
*/
public String getUri() {
return m_nameAttrs.getUri();
}
/**
* Set namespace URI.
*
* @param uri namespace URI (null if not set)
*/
public void setUri(String uri) {
m_nameAttrs.setUri(uri);
}
/**
* Get specified namespace prefix.
*
* @return namespace prefix (null if not set)
*/
public String getPrefix() {
return m_nameAttrs.getPrefix();
}
/**
* Set namespace prefix.
*
* @param prefix namespace prefix (null if not set)
*/
public void setPrefix(String prefix) {
m_nameAttrs.setPrefix(prefix);
}
/**
* Get effective namespace information. This call is only meaningful after
* validation.
*
* @return effective namespace information
*/
public NamespaceElement getNamespace() {
return m_nameAttrs.getNamespace();
}
//
// Property attribute delegate methods
/**
* Get usage name.
*
* @return usage name
*/
public String getUsageName() {
return m_propertyAttrs.getUsageName();
}
/**
* Get usage value. This call is only meaningful after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return usage value
*/
public int getUsage() {
return m_propertyAttrs.getUsage();
}
/**
* Set usage name.
*
* @param name usage name
*/
public void setUsageName(String name) {
m_propertyAttrs.setUsageName(name);
}
/**
* Set usage value.
*
* @param use value
*/
public void setUsage(int use) {
m_propertyAttrs.setUsage(use);
}
/**
* Check if property is defined. This method is only meaningful after
* a call to {@link #prevalidate(ValidationContext)}.
*
* @return true if property defined, false if not
*/
public boolean hasProperty() {
return m_propertyAttrs.hasProperty();
}
/**
* Get declared type name.
*
* @return type name (or null if none)
*/
public String getDeclaredType() {
return m_propertyAttrs.getDeclaredType();
}
/**
* Set declared type name.
*
* @param type name (or null if none)
*/
public void setDeclaredType(String type) {
m_propertyAttrs.setDeclaredType(type);
}
/**
* Get field name.
*
* @return field name (or null if none)
*/
public String getFieldName() {
return m_propertyAttrs.getFieldName();
}
/**
* Get field information. This call is only meaningful after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return field information (or null if none)
*/
public IClassItem getField() {
return m_propertyAttrs.getField();
}
/**
* Set field name.
*
* @param field field name (or null if none)
*/
public void setFieldName(String field) {
m_propertyAttrs.setFieldName(field);
}
/**
* Get test method name.
*
* @return test method name (or null if none)
*/
public String getTestName() {
return m_propertyAttrs.getTestName();
}
/**
* Get test method information. This call is only meaningful after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return test method information (or null if none)
*/
public IClassItem getTest() {
return m_propertyAttrs.getTest();
}
/**
* Set test method name.
*
* @param test test method name (or null if none)
*/
public void setTestName(String test) {
m_propertyAttrs.setTestName(test);
}
/**
* Get get method name.
*
* @return get method name (or null if none)
*/
public String getGetName() {
return m_propertyAttrs.getGetName();
}
/**
* Get get method information. This call is only meaningful after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return get method information (or null if none)
*/
public IClassItem getGet() {
return m_propertyAttrs.getGet();
}
/**
* Get type for value loaded to stack. This call is only meaningful after a
* call to {@link #prevalidate(ValidationContext)}.
*
* @return get value type (or null if none)
*/
public IClass getGetType() {
return m_propertyAttrs.getGetType();
}
/**
* Set get method name.
*
* @param get get method name (or null if none)
*/
public void setGetName(String get) {
m_propertyAttrs.setGetName(get);
}
/**
* Get set method name.
*
* @return set method name (or null if none)
*/
public String getSetName() {
return m_propertyAttrs.getSetName();
}
/**
* Get set method information. This call is only meaningful after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return set method information (or null if none)
*/
public IClassItem getSet() {
return m_propertyAttrs.getSet();
}
/**
* Get type for value stored from stack. This call is only meaningful after
* a call to {@link #prevalidate(ValidationContext)}.
*
* @return set value type (or null if none)
*/
public IClass getSetType() {
return m_propertyAttrs.getSetType();
}
/**
* Set set method name.
*
* @param set set method name (or null if none)
*/
public void setSetName(String set) {
m_propertyAttrs.setSetName(set);
}
/**
* Check if nillable object.
*
* @return nillable flag
*/
public boolean isNillable() {
return m_isNillable;
}
/**
* Set nillable flag.
*
* @param nillable flag
*/
public void setNillable(boolean nillable) {
m_isNillable = nillable;
}
/**
* Check if this value implicitly uses the containing object. This call
* is only meaningful after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return true if using the containing object,
* false if own value
*/
public boolean isImplicit() {
return m_propertyAttrs.isImplicit();
}
//
// String attribute delegate methods
/**
* Get default value text.
*
* @return default value text
*/
public String getDefaultText() {
return m_stringAttrs.getDefaultText();
}
/**
* Get default value. This call is only meaningful after validation.
*
* @return default value object
*/
public Object getDefault() {
return m_stringAttrs.getDefault();
}
/**
* Set default value text.
*
* @param value default value text
*/
public void setDefaultText(String value) {
m_stringAttrs.setDefaultText(value);
}
/**
* Get enum value method information. This method is only usable after a
* call to {@link #validate(ValidationContext)}.
*
* @return enum value method information (or null if none)
*/
public IClassItem getEnumValue() {
return m_stringAttrs.getEnumValue();
}
/**
* Get enum value method name.
*
* @return enum value method name (or null if none)
*/
public String getEnumValueName() {
return m_stringAttrs.getEnumValueName();
}
/**
* Set enum value method name.
*
* @param name enum value method name (null if none)
*/
public void setEnumValueName(String name) {
m_stringAttrs.setEnumValueName(name);
}
/**
* Get base format name.
*
* @return referenced base format
*/
public String getFormatName() {
return m_stringAttrs.getFormatName();
}
/**
* Set base format name.
*
* @param name referenced base format
*/
public void setFormatName(String name) {
m_stringAttrs.setFormatName(name);
}
/**
* Get format qualified name.
*
* @return format qualified name (null if none)
*/
public QName getFormatQName() {
return m_stringAttrs.getFormatQName();
}
/**
* Set format qualified name. This method changes the label value to match
* the qualified name.
*
* @param qname format qualified name (null if none)
*/
public void setFormatQName(QName qname) {
m_stringAttrs.setFormatQName(qname);
}
/**
* Get serializer name.
*
* @return fully qualified class and method name for serializer (or
* null if none)
*/
public String getSerializerName() {
return m_stringAttrs.getSerializerName();
}
/**
* Get serializer method information. This call is only meaningful after
* validation.
*
* @return serializer information (or null if none)
*/
public IClassItem getSerializer() {
return m_stringAttrs.getSerializer();
}
/**
* Set serializer method name.
*
* @param name fully qualified class and method name for serializer
*/
public void setSerializerName(String name) {
m_stringAttrs.setSerializerName(name);
}
/**
* Get deserializer name.
*
* @return fully qualified class and method name for deserializer (or
* null if none)
*/
public String getDeserializerName() {
return m_stringAttrs.getDeserializerName();
}
/**
* Get deserializer method information. This call is only meaningful after
* validation.
*
* @return deserializer information (or null if none)
*/
public IClassItem getDeserializer() {
return m_stringAttrs.getDeserializer();
}
/**
* Set deserializer method name.
*
* @param name fully qualified class and method name for deserializer
*/
public void setDeserializerName(String name) {
m_stringAttrs.setDeserializerName(name);
}
//
// IComponent implementation methods (also delegated name methods)
/* (non-Javadoc)
* @see org.jibx.binding.model.IComponent#hasAttribute()
*/
public boolean hasAttribute() {
return m_styleIndex == NestingAttributes.ATTRIBUTE_STYLE;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IComponent#hasContent()
*/
public boolean hasContent() {
return m_styleIndex != NestingAttributes.ATTRIBUTE_STYLE;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IComponent#isOptional()
*/
public boolean isOptional() {
return m_propertyAttrs.getUsage() == PropertyAttributes.OPTIONAL_USAGE;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IComponent#hasName()
*/
public boolean hasName() {
return m_nameAttrs.getName() != null;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IComponent#getType()
*/
public IClass getType() {
return m_propertyAttrs.getType();
}
//
// Validation methods
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
*/
private void preSet(IUnmarshallingContext uctx) {
validateAttributes(uctx, s_allowedAttributes);
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#prevalidate(org.jibx.binding.model.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// set the style value
if (m_styleName != null) {
m_styleIndex = s_styleEnum.getValue(m_styleName);
if (m_styleIndex < 0) {
vctx.addError("Value \"" + m_styleName +
"\" is not a valid choice for style");
}
} else {
m_styleIndex = vctx.getParentElement().getDefaultStyle();
}
// validate ID classification
m_identIndex = s_identEnum.getValue(m_identName);
if (m_identIndex < 0) {
vctx.addError("Value \"" + m_identName +
" is not a valid choice for ident");
}
// validate basic attribute groups
m_propertyAttrs.prevalidate(vctx);
m_nameAttrs.setIsAttribute
(m_styleIndex == NestingAttributes.ATTRIBUTE_STYLE);
m_nameAttrs.prevalidate(vctx);
if (m_styleIndex == CDATA_STYLE || m_styleIndex == TEXT_STYLE) {
if (m_nameAttrs.getName() != null) {
vctx.addFatal("Values with \"text\" or \"cdata\" style " +
"cannot have names");
}
} else {
if (m_nameAttrs.getName() == null) {
vctx.addFatal
("Missing required name for element or attribute value");
}
}
// make sure value is not constant
if (m_constantValue == null) {
// make sure nillable only for optional element with object
if (m_isNillable) {
if (m_styleIndex != NestingAttributes.ELEMENT_STYLE) {
vctx.addFatal("nillable can only be used with element style");
}
}
// process ID classification
if (m_identIndex == DEF_IDENT/* || m_identIndex == AUTO_IDENT*/) {
boolean valid = false;
IClass gclas = m_propertyAttrs.getGetType();
if (gclas != null) {
String gtype = gclas.getName();
if (gtype.equals("java.lang.String")) {
vctx.getContextObject().setIdChild(this, vctx);
valid = true;
}
}
if (!valid) {
vctx.addError("ID property must supply a " +
"java.lang.String value");
}
}
// check string attributes only if valid to this point
if (!vctx.isSkipped(this)) {
// handle string attributes based on identity type
if (m_identIndex == REF_IDENT) {
if (m_propertyAttrs.isImplicit()) {
vctx.addFatal
("No property value - ID reference can only " +
"be used with a property of the appropriate type");
}
if (m_stringAttrs.getDeserializerName() != null ||
m_stringAttrs.getSerializerName() != null ||
m_stringAttrs.getFormatName() != null ||
m_stringAttrs.getDefaultText() != null) {
vctx.addWarning("String attributes serializer, " +
"deserializer, format, and default are " +
"prohibited with ID references");
}
} else if (m_propertyAttrs.isFlagOnly()) {
if (m_stringAttrs.getDeserializerName() != null ||
m_stringAttrs.getSerializerName() != null ||
m_stringAttrs.getFormatName() != null ||
m_stringAttrs.getDefaultText() != null) {
vctx.addWarning("String attributes serializer, " +
"deserializer, format, and default are " +
"prohibited for flag value");
}
} else {
m_stringAttrs.setType(m_propertyAttrs.getType());
m_stringAttrs.prevalidate(vctx);
}
super.prevalidate(vctx);
}
} else {
// check prohibited attributes with constant value
if (m_identIndex != NONE_IDENT) {
vctx.addFatal("ident value must be \"none\" for constant");
} else if (m_propertyAttrs.hasProperty() ||
m_propertyAttrs.getDeclaredType() != null) {
vctx.addFatal
("Property attributes cannot be used with constant");
} else if (m_stringAttrs.getDefaultText() != null ||
m_stringAttrs.getDeserializerName() != null ||
m_stringAttrs.getSerializerName() != null ||
m_stringAttrs.getFormatName() != null) {
vctx.addFatal("String attributes cannot be used with constant");
} else if (m_isNillable) {
vctx.addFatal("nillable cannot be used with constant");
}
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#validate(org.jibx.binding.model.ValidationContext)
*/
public void validate(ValidationContext vctx) {
// validate basic attributes
m_nameAttrs.validate(vctx);
m_propertyAttrs.validate(vctx);
if (!vctx.isSkipped(this)) {
// check identity references for compatible objects
if (m_identIndex == REF_IDENT) {
String type = m_propertyAttrs.getType().getName();
if (!vctx.getBindingRoot().isIdClass(type)) {
vctx.addError("No ID definitions for compatible type");
}
}
super.validate(vctx);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/BindingUtils.java 0000644 0001750 0001750 00000006503 11526301446 025625 0 ustar twerner twerner /*
* Copyright (c) 2010-2011, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.binding.model;
import java.util.Map;
import org.jibx.runtime.QName;
import org.jibx.util.DummyClassLocator;
/**
* Utility methods to support working with binding definitions.
*
* @author Dennis M. Sosnoski
*/
public class BindingUtils
{
/**
* Find all mapping definitions representing the equivalent of schema type and element definitions. The passed-in
* maps should initially be empty, and will be populated on return.
*
* @param binding root binding definition
* @param types map from qualified name to mapping element for global complex type-equivalent
* @param elems map from qualified name to mapping element for global element
* @param formats map from qualified name to format definition for global simple type-equivalent
*/
public static void getDefinitions(BindingElement binding, final Map types, final Map elems, final Map formats) {
TreeContext ctx = new TreeContext(new DummyClassLocator());
ModelVisitor visitor = new ModelVisitor() {
public boolean visit(MappingElement mapping) {
QName qname = mapping.getTypeQName();
if (qname != null) {
types.put(qname, mapping);
}
String name = mapping.getName();
if (name != null) {
qname = new QName(mapping.getNamespace().getUri(), name);
elems.put(qname, mapping);
}
return false;
}
public boolean visit(FormatElement format) {
QName qname = format.getQName();
if (qname != null) {
formats.put(qname, formats);
}
return false;
}
};
ctx.tourTree(binding, visitor);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/EmptyArrayList.java 0000644 0001750 0001750 00000007370 11124147712 026164 0 ustar twerner twerner /*
Copyright (c) 2004-2008, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.util.ArrayList;
import java.util.Collection;
/**
* Unmodifiable empty array list. This defines a singleton instance of itself,
* which can then be used whereever an empty list is convenient. This class is
* required to support methods which return instances of java.util.ArrayList in
* order to guarantee random access to the returned list in constant time as
* part of the method contract. java.util.Collection.EMPTY_LIST is not an
* instance of java.util.ArrayList, so it cannot be used.
*
* @author Dennis M. Sosnoski
*/
public class EmptyArrayList extends ArrayList
{
public static final EmptyArrayList INSTANCE = new EmptyArrayList();
private EmptyArrayList() {}
public void add(int index, Object element) {
throw new UnsupportedOperationException("List is not modifiable");
}
public boolean add(Object o) {
throw new UnsupportedOperationException("List is not modifiable");
}
public boolean addAll(Collection c) {
throw new UnsupportedOperationException("List is not modifiable");
}
public boolean addAll(int index, Collection c) {
throw new UnsupportedOperationException("List is not modifiable");
}
public void ensureCapacity(int minCapacity) {
throw new UnsupportedOperationException("List is not modifiable");
}
public void clear() {
throw new UnsupportedOperationException("List is not modifiable");
}
public Object remove(int index) {
throw new UnsupportedOperationException("List is not modifiable");
}
public boolean remove(Object o) {
throw new UnsupportedOperationException("List is not modifiable");
}
protected void removeRange(int fromIndex, int toIndex) {
throw new UnsupportedOperationException("List is not modifiable");
}
public Object set(int index, Object element) {
throw new UnsupportedOperationException("List is not modifiable");
}
public void trimToSize() {
throw new UnsupportedOperationException("List is not modifiable");
}
public boolean removeAll(Collection c) {
throw new UnsupportedOperationException("List is not modifiable");
}
public boolean retainAll(Collection c) {
throw new UnsupportedOperationException("List is not modifiable");
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/AttributeBase.java 0000644 0001750 0001750 00000005345 10210703670 025765 0 ustar twerner twerner /*
Copyright (c) 2004-2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
/**
* Base class for all attribute group structures in binding definition model.
* This just provides the basic validation hooks.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public abstract class AttributeBase
{
/**
* Prevalidate attribute information. The prevalidation step is used to
* check attribute values in isolation, such as the settings for enumerated
* values and class file information. This empty base class implementation
* should be overridden by each subclass that requires prevalidation
* handling.
*
* @param vctx validation context
*/
public void prevalidate(ValidationContext vctx) {}
/**
* Validate attribute information. The validation step is used for checking
* the interactions between attributes, such as references to named elements
* and namespace usage. The {@link #prevalidate} method will always be
* called for every component in the binding definition before this method
* is called for any component. This empty base class implementation should
* be overridden by each subclass that requires validation handling.
*
* @param vctx validation context
*/
public void validate(ValidationContext vctx) {}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/ContainerElementBase.java 0000644 0001750 0001750 00000055767 11424506244 027301 0 ustar twerner twerner /*
Copyright (c) 2004-2010, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.util.ArrayList;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
import org.jibx.util.StringArray;
/**
* Model component for elements that can contain detailed binding information in
* the form of nested child components. Elements of this type include
* mapping, template, structure, and collection
* elements.
*
* @author Dennis M. Sosnoski
*/
public abstract class ContainerElementBase extends NestingElementBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(NestingElementBase.s_allowedAttributes,
new StringArray(ObjectAttributes.s_allowedAttributes,
StructureAttributes.s_allowedAttributes));
/** Object attributes information for nesting. */
private ObjectAttributes m_objectAttrs;
/** Structure attributes information for nesting. */
private StructureAttributes m_structureAttrs;
/** Label for this structure definition. */
private String m_label;
/** Label for structure to be used as definition. */
private String m_using;
/** Child component that contributes an ID (null if none). */
private IComponent m_idChild;
/** Flag for child classification in progress. */
private boolean m_inClassify;
/** Child components defining content (created during validation, contains
subset of child components defining element or character data content). */
private ArrayList m_contentComponents;
/** Child components defining attributes (created during validation,
contains subset of child components defining attributes). */
private ArrayList m_attributeComponents;
/**
* Constructor.
*
* @param type element type code
*/
protected ContainerElementBase(int type) {
super(type);
m_objectAttrs = new ObjectAttributes();
m_structureAttrs = new StructureAttributes();
}
/**
* Get label for this definition.
*
* @return label for this definition
*/
public String getLabel() {
return m_label;
}
/**
* Set label for this definition.
*
* @param label label for this definition
*/
public void setLabel(String label) {
m_label = label;
}
/**
* Get label for definition to be used.
*
* @return label for definition to be used
*/
public String getUsing() {
return m_using;
}
/**
* Set label for definition to be used.
*
* @param label label for definition to be used
*/
public void setUsing(String label) {
m_using = label;
}
/**
* Get list of child components contributing content items to this
* container element. This call is only meaningful after validation.
*
* @return list of child binding components defining content items
*/
public ArrayList getContentComponents() {
return m_contentComponents == null ?
EmptyArrayList.INSTANCE : m_contentComponents;
}
/**
* Get list of child components contributing attribute items to this
* container element. This call is only meaningful after validation.
*
* @return list of child binding components defining attribute items
*/
public ArrayList getAttributeComponents() {
return m_attributeComponents == null ?
EmptyArrayList.INSTANCE : m_attributeComponents;
}
/**
* Check if this container defines a context object.
*
* @return true if defines context object,
* false if not
*/
public abstract boolean hasObject();
/**
* Get class linked to binding element. This call is only meaningful after
* validation.
*
* @return information for class linked by binding
*/
public abstract IClass getObjectType();
/**
* Get class passed to child components. This call is only meaningful after
* validation.
*
* @return information for class linked by binding
*/
public IClass getChildObjectType() {
return getObjectType();
}
/**
* Set ID property child. Used to set the ID property associated with a
* particular class instance. There can only be at most one child ID
* property for each actual object instance.
*
* @param child child defining the ID property
* @param vctx validation context
*/
public final void setIdChild(IComponent child, ValidationContext vctx) {
if (m_idChild == null) {
m_idChild = child;
vctx.getBindingRoot().addIdClass(getObjectType());
} else {
vctx.addError("Only one child ID property allowed for an object " +
"- " + ValidationProblem.componentDescription(m_idChild) +
" and " + ValidationProblem.componentDescription(child) +
" refer to the same object");
}
}
/**
* Get ID property child.
*
* @return ID child
*/
public IComponent getId() {
return m_idChild;
}
//
// Object attribute delegate methods
/**
* Get factory method name.
*
* @return fully-qualified factory class and method name (or
* null if none)
*/
public String getFactoryName() {
return m_objectAttrs.getFactoryName();
}
/**
* Get factory method information. This call is only meaningful after
* a call to {@link #prevalidate(ValidationContext)}.
*
* @return factory method information (or null if none)
*/
public IClassItem getFactory() {
return m_objectAttrs.getFactory();
}
/**
* Set factory method name.
*
* @param name fully qualified class and method name for object factory
*/
public void setFactoryName(String name) {
m_objectAttrs.setFactoryName(name);
}
/**
* Get pre-set method name.
*
* @return pre-set method name (or null if none)
*/
public String getPresetName() {
return m_objectAttrs.getPresetName();
}
/**
* Get pre-set method information. This call is only meaningful after
* a call to {@link #prevalidate(ValidationContext)}.
*
* @return pre-set method information (or null if none)
*/
public IClassItem getPreset() {
return m_objectAttrs.getPreset();
}
/**
* Set pre-set method name.
*
* @param name member method name to be called before unmarshalling
*/
public void setPresetName(String name) {
m_objectAttrs.setPresetName(name);
}
/**
* Get post-set method name.
*
* @return post-set method name (or null if none)
*/
public String getPostsetName() {
return m_objectAttrs.getPostsetName();
}
/**
* Get post-set method information. This call is only meaningful after
* a call to {@link #prevalidate(ValidationContext)}.
*
* @return post-set method information (or null if none)
*/
public IClassItem getPostset() {
return m_objectAttrs.getPostset();
}
/**
* Set post-set method name.
*
* @param name member method name to be called after unmarshalling
*/
public void setPostsetName(String name) {
m_objectAttrs.setPostsetName(name);
}
/**
* Get pre-get method name.
*
* @return pre-get method name (or null if none)
*/
public String getPregetName() {
return m_objectAttrs.getPregetName();
}
/**
* Get pre-get method information. This call is only meaningful after
* a call to {@link #prevalidate(ValidationContext)}.
*
* @return pre-get method information (or null if none)
*/
public IClassItem getPreget() {
return m_objectAttrs.getPreget();
}
/**
* Set pre-get method name.
*
* @param name member method name to be called before marshalling
*/
public void setPregetName(String name) {
m_objectAttrs.setPregetName(name);
}
/**
* Get marshaller class name.
*
* @return marshaller class name (or null if none)
*/
public String getMarshallerName() {
return m_objectAttrs.getMarshallerName();
}
/**
* Get marshaller class information. This call is only meaningful after
* a call to {@link #prevalidate(ValidationContext)}.
*
* @return class information for marshaller (or null if none)
*/
public IClass getMarshaller() {
return m_objectAttrs.getMarshaller();
}
/**
* Set marshaller class name.
*
* @param name class name to be used for marshalling
*/
public void setMarshallerName(String name) {
m_objectAttrs.setMarshallerName(name);
}
/**
* Get unmarshaller class name.
*
* @return unmarshaller class name (or null if none)
*/
public String getUnmarshallerName() {
return m_objectAttrs.getUnmarshallerName();
}
/**
* Get unmarshaller class information. This call is only meaningful after
* a call to {@link #prevalidate(ValidationContext)}.
*
* @return class information for unmarshaller (or null if none)
*/
public IClass getUnmarshaller() {
return m_objectAttrs.getUnmarshaller();
}
/**
* Set unmarshaller class name.
*
* @param name class name to be used for unmarshalling
*/
public void setUnmarshallerName(String name) {
m_objectAttrs.setUnmarshallerName(name);
}
/**
* Check if nillable object.
*
* @return nillable flag
*/
public boolean isNillable() {
return m_objectAttrs.isNillable();
}
/**
* Set nillable flag.
*
* @param nillable flag
*/
public void setNillable(boolean nillable) {
m_objectAttrs.setNillable(nillable);
}
/**
* Get type to be used for creating new instance.
*
* @return class name for type to be created (or null if none)
*/
public String getCreateType() {
return m_objectAttrs.getCreateType();
}
/**
* Get new instance creation class information. This method is only usable
* a call to {@link #prevalidate(ValidationContext)}.
*
* @return class information for type to be created (or null if
* none)
*/
public IClass getCreateClass() {
return m_objectAttrs.getCreateClass();
}
/**
* Set new instance type class name.
*
* @param name class name to be used for creating new instance
*/
public void setCreateType(String name) {
m_objectAttrs.setCreateType(name);
}
//
// Structure attribute delegate methods
/**
* Get flexible flag.
*
* @return flexible flag
*/
public boolean isFlexible() {
return m_structureAttrs.isFlexible();
}
/**
* Set flexible flag.
*
* @param flexible
*/
public void setFlexible(boolean flexible) {
m_structureAttrs.setFlexible(flexible);
}
/**
* Check if child components are ordered.
*
* @return true if ordered, false if not
*/
public boolean isOrdered() {
return m_structureAttrs.isOrdered();
}
/**
* Set child components ordered flag.
*
* @param ordered true if ordered, false if not
*/
public void setOrdered(boolean ordered) {
m_structureAttrs.setOrdered(ordered);
}
/**
* Check if child components are a choice.
*
* @return true if choice, false if not
*/
public boolean isChoice() {
return m_structureAttrs.isChoice();
}
/**
* Set child components choice flag.
*
* @param choice true if choice, false if not
*/
public void setChoice(boolean choice) {
m_structureAttrs.setChoice(choice);
}
/**
* Check if repeated child elements are allowed.
*
* @return true if repeats allowed, false if not
*/
public boolean isAllowRepeats() {
return m_structureAttrs.isAllowRepeats();
}
/**
* Set repeated child elements allowed flag.
*
* @param ignore true if repeated child elements to be allowed,
* false if not
*/
public void setAllowRepeats(boolean ignore) {
m_structureAttrs.setAllowRepeats(ignore);
}
//
// Validation methods.
/**
* Check that there's a way to construct an instance of an object class for
* input bindings. This can be a factory method, an unmarshaller, a
* no-argument constructor already defined in the class, or a modifiable
* class with constructor generation enabled. If a create-type is specified,
* this is used in place of the declared type. The call always succeeds if
* the binding is output-only.
*
* Note that this method should not be changed to pass the "this" object
* when reporting errors, because it may be called indirectly during the
* validation of other elements. Because of this, it needs to only use
* values defined after {@link #prevalidate(ValidationContext)}.
*
* @param vctx validation context
* @param type constructed object type
*/
protected void verifyConstruction(ValidationContext vctx, IClass type) {
if (vctx.isInBinding() && getFactory() == null &&
getUnmarshaller() == null) {
IClass create = getCreateClass();
if (create != null) {
if (create.isAssignable(type)) {
type = create;
} else {
vctx.addError("Specified create-type '" + create.getName() +
"' is not compatible with type '" +
type.getName() + '\'');
}
}
if (type.isAbstract()) {
vctx.addError("factory-method needed for abstract type '" +
type.getName() + '\'');
} else if (!type.getName().endsWith("[]") &&
type.getInitializerMethod("()V") == null &&
!"java.lang.Enum".equals(type.getSuperClass().getName())) {
BindingElement binding = vctx.getBindingRoot();
if (binding.isAddConstructors()) {
if (!type.isModifiable()) {
vctx.addError("Need no-argument constructor or " +
"factory method for unmodifiable class " +
type.getName());
} else {
IClass suptype = type;
while ((suptype = suptype.getSuperClass()) != null) {
IClassItem cons = suptype.getInitializerMethod("()V");
if ((cons == null || !type.isAccessible(cons)) &&
!suptype.isModifiable()) {
vctx.addError("Need accessible no-argument constructor for unmodifiable class " +
suptype.getName() + " (superclass of " + type.getName() + ')');
}
}
}
} else {
vctx.addError("Need no-argument constructor or " +
"factory method for class " + type.getName());
}
}
}
}
/**
* Check that child components are of types compatible with the container
* object type. This method may call itself recursively to process the
* children of child components which do not themselves set a type. It's not
* used directly, but is here for use by subclasses.
*
* @param vctx validation context
* @param type structure object type
* @param children list of child components to be checked
*/
protected void checkCompatibleChildren(ValidationContext vctx, IClass type,
ArrayList children) {
for (int i = 0; i < children.size(); i++) {
ElementBase child = (ElementBase)children.get(i);
boolean expand = true;
if (child instanceof IComponent && !vctx.isSkipped(child)) {
IComponent comp = (IComponent)child;
IClass ctype = comp.getType();
if (comp instanceof ContainerElementBase) {
ContainerElementBase contain = (ContainerElementBase)comp;
expand = !contain.hasObject();
}
if (comp.isImplicit()) {
if (!type.isAssignable(ctype)) {
vctx.addFatal
("References to structure object must have " +
"compatible types: " + type.getName() +
" cannot be used as " + ctype.getName(), child);
}
}
}
if (expand && child instanceof NestingElementBase) {
checkCompatibleChildren(vctx, type,
((NestingElementBase)child).children());
}
}
}
/**
* Check for child components classified. This is a convenience method for
* subclasses to check if classification has already been done.
*
* @return true if classified, false if not
*/
protected boolean isClassified() {
return m_attributeComponents != null;
}
/**
* Classify child components as contributing attributes, content, or both.
* This method is needed to handle on-demand classification during
* validation. When a child component is another instance of this class, the
* method calls itself on the child component prior to checking the child
* component's contribution.
*
* @param vctx
*/
protected void classifyComponents(ValidationContext vctx) {
if (m_attributeComponents == null && !m_inClassify) {
ArrayList childs = children();
if (childs == null || childs.size() == 0) {
// no children, so no components of either type
m_attributeComponents = EmptyArrayList.INSTANCE;
m_contentComponents = EmptyArrayList.INSTANCE;
} else {
// classify child components, setting flag to catch recursion
m_inClassify = true;
m_attributeComponents = new ArrayList();
m_contentComponents = new ArrayList();
for (int i = 0; i < childs.size(); i++) {
Object child = childs.get(i);
if (child instanceof ContainerElementBase) {
ContainerElementBase contain = (ContainerElementBase)child;
vctx.pushNode(contain);
contain.classifyComponents(vctx);
vctx.popNode();
}
if (child instanceof IComponent) {
IComponent comp = (IComponent)child;
if (comp.hasAttribute()) {
m_attributeComponents.add(child);
}
if (comp.hasContent()) {
m_contentComponents.add(child);
if (!comp.hasName()) {
if (isFlexible()) {
vctx.addError("All child components must define element names for flexible='true'", comp);
} else if (comp instanceof ValueElement &&
!isOrdered()) {
vctx.addError("Text values cannot be used with ordered='false'", comp);
}
}
}
}
}
m_inClassify = false;
}
}
}
/**
* Set child attribute and content components directly. This is provided for
* use by subclasses requiring special handling, in particular the
* <structure> element used as a mapping reference.
*
* @param attribs
* @param contents
*/
protected void setComponents(ArrayList attribs, ArrayList contents) {
m_attributeComponents = attribs;
m_contentComponents = contents;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#prevalidate(org.jibx.binding.model.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
m_objectAttrs.prevalidate(vctx);
m_structureAttrs.prevalidate(vctx);
if (m_using != null && children().size() > 0) {
vctx.addFatal("Child elements not allowed with using attribute");
}
super.prevalidate(vctx);
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#validate(org.jibx.binding.model.ValidationContext)
*/
public void validate(ValidationContext vctx) {
super.validate(vctx);
m_objectAttrs.validate(vctx);
m_structureAttrs.validate(vctx);
classifyComponents(vctx);
if (isChoice() && m_attributeComponents.size() > 0) {
vctx.addError("Attributes cannot be included in choice");
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/BindingOrganizer.java 0000644 0001750 0001750 00000113060 11424557762 026475 0 ustar twerner twerner /*
* Copyright (c) 2008-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.binding.model;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Logger;
import org.jibx.binding.Utility;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IMarshallable;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.runtime.impl.MarshallingContext;
import org.jibx.util.InsertionOrderedMap;
import org.jibx.util.InsertionOrderedSet;
import org.jibx.util.LazyList;
import org.jibx.util.UniqueNameSet;
/**
* Organizer for a set of bindings under construction. This tracks the individual bindings by default namespace or by
* associated object (to allow multiple bindings using a single namespace), and manages the relationships between the
* different bindings.
*
* @author Dennis M. Sosnoski
*/
public class BindingOrganizer
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(BindingOrganizer.class.getName());
/** Base prefix used when no prefix set for namespace. */
private static final String BASE_PREFIX = "ns";
//
// Flags to initialize constructed bindings
private final boolean m_forceClasses;
private final boolean m_trackSource;
private final boolean m_addConstructors;
private final boolean m_inBinding;
private final boolean m_outBinding;
private final boolean m_trimWhitespace;
/** Map from namespace URI to prefix, for bindings with prefix specified. */
private final Map m_uriPrefixFixed;
/** Map from namespace URI to default prefix for that namespace. */
private final Map m_uriPrefixDefaults;
/** List of unique key objects for bindings. Multiple key objects may be supplied for each binding, so this just
tracks the one used when initially creating the binding. */
private final List m_keyObjects;
/** Map from object to binding holder for that namespace. */
private final Map m_objectBindings;
/** Map from namespace URIs referenced in bindings not using that namespace to first referencing binding. */
private final Map m_referenceUriBinding;
/** Set of namespace URIs needing to be defined in root binding. */
private final Set m_nsRootUris;
/** List of format definitions in bindings. */
private final List m_formats;
/** Flag for no-namespace namespace used from namespaced binding. */
private boolean m_nonamespaceUsed;
/** Bindings finalized flag. */
private boolean m_finished;
/**
* Constructor taking flags used with constructed bindings.
*
* @param force force classes flag
* @param track track source flag
* @param addcon add constructors flag
* @param in input binding flag
* @param out output binding flag
* @param trim trim whitespace flag
*/
public BindingOrganizer(boolean force, boolean track, boolean addcon, boolean in, boolean out, boolean trim) {
s_logger.debug("Created binding organizer with force=" + force + ", track=" + track + ", addcon=" + addcon + ", in=" + in + ", out=" + out);
m_uriPrefixFixed = new HashMap();
m_forceClasses = force;
m_trackSource = track;
m_addConstructors = addcon;
m_inBinding = in;
m_outBinding = out;
m_trimWhitespace = trim;
m_uriPrefixDefaults = new HashMap();
m_keyObjects = new ArrayList();
m_objectBindings = new HashMap();
m_referenceUriBinding = new InsertionOrderedMap();
m_nsRootUris = new InsertionOrderedSet();
m_formats = new LazyList();
}
/**
* Add a binding to the set in use.
*
* @param obj object associated with binding (can be namespace URI, if only one binding per namespace)
* @param uri namespace URI (null if no namespace)
* @param prefix namespace prefix (null if not specified, empty string if unprefixed default namespace)
* @param dflt namespace is default for elements in binding flag
* @return created binding holder
*/
public BindingHolder addBinding(Object obj, String uri, String prefix, boolean dflt) {
// check for errors with no-namespace namespace
if (uri == null) {
if (!dflt) {
s_logger.error("No-namespace namespace must be element default");
throw new IllegalArgumentException("Internal error - no-namespace namespace must be element default");
}
if (prefix != null && prefix.length() > 0) {
s_logger.error("Cannot use prefix ('" + prefix + "' requested) for no-namespace namespace");
throw new IllegalArgumentException("Configuration error - cannot use prefix ('" + prefix + "' requested) for no-namespace namespace");
} else {
prefix = "";
}
}
// configure binding holder and prefix
BindingHolder hold = new BindingHolder(uri, dflt, this);
m_keyObjects.add(obj);
m_objectBindings.put(obj, hold);
if (prefix != null) {
String prior = (String)m_uriPrefixFixed.get(uri);
if (prior == null) {
m_uriPrefixFixed.put(uri, prefix);
} else if (!prior.equals(prefix)) {
s_logger.error("Conflicting prefixes ('" + prefix + "' and '" + prior + "') for namespace " + uri);
throw new IllegalArgumentException("Configuration error - conflicting prefixes ('" + prefix + "' and '" + prior + "') for namespace " + uri);
}
hold.setPrefix(prefix);
}
if (s_logger.isDebugEnabled()) {
s_logger.debug("Added binding associatiated with " + obj + " with namespace " + uri + " and prefix " + prefix + " (dflt=" + dflt + ')');
}
// configure the actual binding element
BindingElement binding = hold.getBinding();
binding.setForceClasses(m_forceClasses);
binding.setTrackSource(m_trackSource);
binding.setAddConstructors(m_addConstructors);
binding.setInBinding(m_inBinding);
binding.setOutBinding(m_outBinding);
binding.setTrimWhitespace(m_trimWhitespace);
return hold;
}
/**
* Get the binding associated with a particular control object and namespace, if defined.
*
* @param obj object associated with binding
* @return binding holder, or null if not yet defined
*/
public BindingHolder getBinding(Object obj) {
return (BindingHolder)m_objectBindings.get(obj);
}
/**
* Get the binding associated with a particular control object.
*
* @param obj object associated with binding (can be namespace URI, if only one binding per namespace)
* @return binding holder
*/
public BindingHolder getRequiredBinding(Object obj) {
BindingHolder hold = (BindingHolder)m_objectBindings.get(obj);
if (hold == null) {
s_logger.error("Missing required binding for object " + obj);
throw new IllegalStateException("Internal error - binding not defined for " + obj);
} else {
return hold;
}
}
/**
* Associate a control object with an existing binding. The control object is added in addition to any other control
* objects for that binding, so that the binding will be returned when any of the control objects is used for look
* up.
*
* @param obj object associated with binding (can be namespace URI, if only one binding per namespace)
* @param holder binding holder
*/
public void addBindingObject(Object obj, BindingHolder holder) {
m_objectBindings.put(obj, holder);
}
/**
* Set the default prefix for a namespace, if none already set.
*
* @param uri namespace URI
* @param pref prefix to be used (empty string if to be default namespace)
*/
public void addDefaultPrefix(String uri, String pref) {
if (!m_uriPrefixDefaults.containsKey(uri)) {
m_uriPrefixDefaults.put(uri, pref);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Added default prefix '" + pref + "' for namespace " + uri);
}
}
}
/**
* Force specified prefix to be used for binding.
*
* @param prefix
* @param holder
*/
public void forceBindingPrefix(String prefix, BindingHolder holder) {
holder.setPrefix(prefix);
}
/**
* General object comparison method. Don't know why Sun hasn't seen fit to include this somewhere, but at least it's
* easy to write (over and over again).
*
* @param a first object to be compared
* @param b second object to be compared
* @return true if both objects are null, or if a.equals(b);
* false otherwise
*/
public static boolean isEqual(Object a, Object b) {
return (a == null) ? b == null : a.equals(b);
}
/**
* Internal check method to verify that the collection of bindings is still modifiable.
*/
private void checkModifiable() {
if (m_finished) {
throw new IllegalStateException("Internal error - attempt to modify bindings after finalized");
}
}
/**
* Add usage of namespace for an element or attribute name in binding, assuring that the namespace definition will
* be in-scope for that binding. If a namespace is defined by one binding and referenced by another, or if it's
* referenced by more than one binding, it will be defined at the root binding level. This method is used as a
* callback from the binding holder code, in order to track usage of namespaces across all bindings.
*
* @param hold binding containing usage
* @param uri referenced namespace URI (null if no-namespace)
*/
/*default*/ void addNamespaceUsage(BindingHolder hold, String uri) {
// first check if anything needs to be done
checkModifiable();
if (uri == null) {
m_nonamespaceUsed = true;
} else if (!MarshallingContext.XML_NAMESPACE.equals(uri) && !uri.equals(hold.getNamespace()) &&
!m_nsRootUris.contains(uri)) {
// check if any other binding has previously referenced this namespace
BindingHolder refhold = (BindingHolder)m_referenceUriBinding.get(uri);
if (refhold == null) {
// first reference, just record it in map in case also used by another binding
m_referenceUriBinding.put(uri, hold);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Recorded first usage of namespace " + uri + " from binding with namespace " + hold.getNamespace());
}
} else if (refhold != hold) {
// multiple reference, add namespace binding definition to root binding
m_nsRootUris.add(uri);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Added namespace definition for " + uri + " to root binding after reference from binding with namespace " + hold.getNamespace());
}
}
}
}
/**
* Add reference from binding to a type name defined in the same or another binding.
*
* @param hold binding containing reference
* @param uri namespace URI for type name
* @param obj object associated with referenced binding
*/
public void addTypeNameReference(BindingHolder hold, String uri, Object obj) {
checkModifiable();
if (uri != null && hold.getReferencedNamespaces().add(uri)) {
BindingHolder tohold = getRequiredBinding(obj);
if (hold != tohold) {
tohold.forcePullUpNamespaces();
}
if (s_logger.isDebugEnabled()) {
s_logger.debug("Added reference to binding with namespace " + uri +
" from binding with namespace " + hold.getNamespace());
}
}
}
/**
* Add a format definition to the binding.
*
* @param format
*/
public void addFormat(FormatElement format) {
checkModifiable();
m_formats.add(format);
}
/**
* Iterate the collection of bindings. null values may be present in the collection, due to bindings
* which have been eliminated.
*
* @return iterator
*/
public Iterator iterateBindings() {
return m_objectBindings.values().iterator();
}
/**
* Adds a collection of namespace URIs to be referenced at root binding level.
*
* @param uris
*/
public void addRootUris(Collection uris) {
m_nsRootUris.addAll(uris);
}
/**
* Get the list of binding key objects.
*
* @return keys
*/
public List getKeys() {
return m_keyObjects;
}
/**
* Check if a character is an ASCII alpha character.
*
* @param chr
* @return alpha character flag
*/
private static boolean isAsciiAlpha(char chr) {
return (chr >= 'a' && chr <= 'z') || (chr >= 'A' && chr <= 'Z');
}
/**
* Check if a character is an ASCII numeric character.
*
* @param chr
* @return numeric character flag
*/
private static boolean isAsciiNum(char chr) {
return chr >= '0' && chr <= '9';
}
/**
* Check if a character is an ASCII alpha or numeric character.
*
* @param chr
* @return alpha or numeric character flag
*/
private static boolean isAsciiAlphaNum(char chr) {
return isAsciiAlpha(chr) || isAsciiNum(chr);
}
/**
* Generate prefix if not already set for namespace.
*
* @param uri
* @param prefset
* @param uridfltprefs
*/
private void generatePrefix(String uri, UniqueNameSet prefset, Map uridfltprefs) {
if (uri != null && !uridfltprefs.containsKey(uri)) {
String prefix = prefset.add(BASE_PREFIX);
uridfltprefs.put(uri, prefix);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Assigned generated prefix '" + prefix + "' for namespace " + uri);
}
}
}
/**
* Set the default prefixes to be used for namespaces. As part of constructing the map it also checks for
* conflicts on specified prefixes for namespaces used at the root binding level. This is a complex process, due to
* the way namespaces work across bindings with abstract mapping references. Since an abstract mapping doesn't
* define a wrapper element, all namespaces used by the abstract mapping need to be declared on the containing
* element. In practice, this means that any namespaces in the binding defining the abstract mapping need to be
* merged into the set of namespaces in the binding making the reference, and these namespaces all must use distinct
* prefixes. Furthermore, a static analysis of the namespace usage may not be enough to detect conflicts in usage,
* since even if there are no conflicts in a set of binding definitions conflicts may be created when these bindings
* are referenced from other bindings (either through direct includes, or as precompiled bindings).
*
* This code checks for any direct conflicts on namespaces with specified prefixes which are being defined in the
* root binding and throws an exception if such a conflict is found, and creates guaranteed-unique prefixes in cases
* where no prefixes are provided (either as specified values or as defaults). It does not prevent the user from
* either specifying prefixes or using default prefixes which may result in conflicts when the bindings are used by
* other bindings.
*
* @param prefset prefixes in use
* @param nsdfltpref map from namespace URI to default prefix (null value for namespace used as the
* default allowed)
* @return map from namespace URI to non-null and non-empty prefix (used for namespace declarations)
*/
private Map buildDefaultPrefixes(UniqueNameSet prefset, Map nsdfltpref) {
// start by checking for no-namespace namespace used
if (m_nonamespaceUsed) {
prefset.add("");
nsdfltpref.put(null, "");
}
// check if namespaces are being defined in root binding
if (m_nsRootUris.size() > 0) {
// set prefix for every namespace used at root level (with unique value if constructed). this first pass
// attempts to use prefixes which have been set on bindings (if any).
if (m_uriPrefixFixed.size() > 0) {
s_logger.debug("Setting prefixes for namespaces used at root level based on prefixes specified for bindings...");
for (Iterator iter = m_nsRootUris.iterator(); iter.hasNext();) {
String uri = (String)iter.next();
if (!nsdfltpref.containsKey(uri)) {
String prefix = (String)m_uriPrefixFixed.get(uri);
if (prefset.contains(prefix)) {
s_logger.debug("Conflicting use of prefix '" + prefix + "' for multiple namespaces used in root binding");
throw new IllegalStateException("Conflicting use of prefix '" + prefix + "' for multiple namespaces used in root binding - change one of the uses of this prefix");
} else if (prefix != null) {
nsdfltpref.put(uri, prefix);
prefset.add(prefix);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Assigned prefix '" + prefix + "' for namespace " + uri);
}
}
}
}
}
// second pass of setting prefix for namespaces used at root level uses configured defaults (if any)
if (m_uriPrefixDefaults.size() > 0 && nsdfltpref.size() < m_nsRootUris.size()) {
s_logger.debug("Setting prefixes for namespaces used at root level based on configured default prefixes...");
for (Iterator iter = m_nsRootUris.iterator(); iter.hasNext();) {
String uri = (String)iter.next();
if (!nsdfltpref.containsKey(uri)) {
String prefix = (String)m_uriPrefixDefaults.get(uri);
if (!prefset.contains(prefix)) {
nsdfltpref.put(uri, prefix);
prefset.add(prefix);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Assigned prefix '" + prefix + "' for namespace " + uri);
}
}
}
}
}
// third pass of setting prefix for namespaces used at root level uses unique generated prefixes
if (!prefset.contains(BASE_PREFIX)) {
prefset.add(BASE_PREFIX);
}
if (nsdfltpref.size() < m_nsRootUris.size()) {
s_logger.debug("Generating prefixes for remaining namespaces used at root level...");
for (Iterator iter = m_nsRootUris.iterator(); iter.hasNext();) {
generatePrefix((String)iter.next(), prefset, nsdfltpref);
}
}
} else {
prefset.add(BASE_PREFIX);
}
// now that prefixes are configured for namespaces used at root level, add other default prefixes
if (m_uriPrefixFixed.size() > 0) {
s_logger.debug("Setting namespace prefixes based on prefixes specified for bindings...");
for (Iterator iter = m_uriPrefixFixed.keySet().iterator(); iter.hasNext();) {
String uri = (String)iter.next();
if (!nsdfltpref.containsKey(uri)) {
String prefix = (String)m_uriPrefixFixed.get(uri);
if (!prefset.contains(prefix)) {
nsdfltpref.put(uri, prefix);
prefset.add(prefix);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Assigned prefix '" + prefix + "' for namespace " + uri);
}
}
}
}
}
if (m_uriPrefixDefaults.size() > 0) {
s_logger.debug("Setting namespace prefixes based on configured defaults...");
for (Iterator iter = m_uriPrefixDefaults.keySet().iterator(); iter.hasNext();) {
String uri = (String)iter.next();
if (!nsdfltpref.containsKey(uri)) {
String prefix = (String)m_uriPrefixDefaults.get(uri);
if (!prefset.contains(prefix)) {
nsdfltpref.put(uri, prefix);
prefset.add(prefix);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Assigned prefix '" + prefix + "' for namespace " + uri);
}
}
}
}
}
// finally, collect all used and referenced namespaces and create default prefixes for any which don't already
// have them
s_logger.debug("Finish prefix assignment for all namespaces referenced or used...");
for (Iterator iter = m_keyObjects.iterator(); iter.hasNext();) {
BindingHolder holder = (BindingHolder)m_objectBindings.get(iter.next());
String uri = holder.getNamespace();
if (holder.isBindingNamespaceUsed() && !holder.isNamespaceElementDefault()) {
generatePrefix(uri, prefset, nsdfltpref);
} else if (!nsdfltpref.containsKey(uri)) {
nsdfltpref.put(uri, "");
}
for (Iterator jter = holder.getReferencedNamespaces().iterator(); jter.hasNext();) {
generatePrefix((String)jter.next(), prefset, nsdfltpref);
}
for (Iterator jter = holder.getUsedNamespaces().iterator(); jter.hasNext();) {
generatePrefix((String)jter.next(), prefset, nsdfltpref);
}
}
// finish by building second map with an actual prefix for every namespace
s_logger.debug("Generate prefixes for namespaces used as default...");
Map frcedprfx = new HashMap();
for (Iterator iter = nsdfltpref.keySet().iterator(); iter.hasNext();) {
String uri = (String)iter.next();
String prefix = (String)nsdfltpref.get(uri);
if (prefix == null || prefix.length() == 0) {
prefix = prefset.add(BASE_PREFIX);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Assigned generated prefix '" + prefix + "' for namespace " + uri);
}
}
frcedprfx.put(uri, prefix);
}
return frcedprfx;
}
/**
* Configure the names to be used for writing bindings to files. If only one binding has been defined, it just gets
* the supplied name. If multiple bindings have been defined, a single root binding is constructed which includes
* all the other bindings and defines namespaces for those bindings, all <format> definitions are moved to that
* root binding, and is is given the supplied name while the other bindings are given unique names within the same
* directory.
*
* @param rootname file name for root or singleton binding definition
* @param trgtpack target package for binding (null if unspecified)
* @param pregens pregenerated bindings to be included in root binding
* @return root or singleton binding holder
*/
public BindingHolder configureFiles(String rootname, String trgtpack, List pregens) {
// make sure not already called
checkModifiable();
// discard any bindings with no mappings (unless only one binding)
List objs;
if (m_objectBindings.size() > 1) {
objs = new ArrayList();
for (Iterator iter = m_keyObjects.iterator(); iter.hasNext();) {
Object obj = iter.next();
BindingHolder hold = (BindingHolder)m_objectBindings.get(obj);
if (hold.getMappingCount() > 0) {
objs.add(obj);
} else {
m_objectBindings.put(obj, null);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Eliminated empty binding associated with " + obj);
}
}
}
m_keyObjects.clear();
m_keyObjects.addAll(objs);
} else {
objs = m_keyObjects;
}
// finish set of namespace definitions for root binding, by checking for those both referenced in one binding
// and defined in another (multiple references already handled at time reference was reported), and for
// namespaces to be pulled up to root binding
for (Iterator iter1 = objs.iterator(); iter1.hasNext();) {
Object obj = iter1.next();
BindingHolder hold = (BindingHolder)m_objectBindings.get(obj);
String uri = hold.getNamespace();
if (uri != null && !MarshallingContext.XML_NAMESPACE.equals(uri) && !m_nsRootUris.contains(uri) &&
m_referenceUriBinding.get(uri) != null) {
m_nsRootUris.add(uri);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Added namespace " + uri + " to set defined in root binding based on reference and usage");
}
}
if (hold.isPullUpNamespaces()) {
for (Iterator iter2 = hold.getUsedNamespaces().iterator(); iter2.hasNext();) {
String useduri = (String)iter2.next();
if (useduri != null && !MarshallingContext.XML_NAMESPACE.equals(useduri)) {
m_nsRootUris.add(useduri);
}
}
if (s_logger.isDebugEnabled()) {
s_logger.debug("Added all namespaces used in binding associated with " + obj + " to set defined in root binding based on abstract mapping usage");
}
}
}
// define the namespace prefixes to be used (unless otherwise specified at individual binding level)
UniqueNameSet prefset = new UniqueNameSet();
Map uridfltpref = new HashMap();
Map urifrcdpref = buildDefaultPrefixes(prefset, uridfltpref);
// check if only single binding defined
BindingHolder roothold = null;
BindingElement rootbind;
List includes = new ArrayList(pregens);
if (objs.size() == 1) {
// single binding, just write it using supplied name and added namespaces
roothold = (BindingHolder)m_objectBindings.get(objs.get(0));
rootbind = roothold.getBinding();
} else {
// first look for existing binding with supplied name
for (Iterator iter = objs.iterator(); iter.hasNext();) {
BindingHolder hold = (BindingHolder)m_objectBindings.get(iter.next());
if (rootname.equals(hold.getFileName())) {
roothold = hold;
break;
}
}
if (roothold == null) {
// get or create no namespace binding
roothold = getBinding(null);
if (roothold == null) {
roothold = addBinding(null, null, "", true);
}
}
rootbind = roothold.getBinding();
// add root binding namespace to set declared at root
if (roothold.isBindingNamespaceUsed()) {
String uri = roothold.getNamespace();
if (uri != null && !MarshallingContext.XML_NAMESPACE.equals(uri)) {
m_nsRootUris.add(uri);
}
}
// set file names and add to list for root binding
UniqueNameSet nameset = new UniqueNameSet();
nameset.add(rootname);
for (Iterator iter = objs.iterator(); iter.hasNext();) {
BindingHolder holder = (BindingHolder)m_objectBindings.get(iter.next());
if (holder != roothold) {
if (holder.getFileName() == null) {
// get last part of namespace URI as file name candidate
String bindname;
String raw = holder.getNamespace();
if (raw == null) {
bindname = "nonamespaceBinding";
} else {
// strip off protocol and any trailing slash
raw = raw.replace('\\', '/');
int split = raw.indexOf("://");
if (split >= 0) {
raw = raw.substring(split + 3);
}
while (raw.endsWith("/")) {
raw = raw.substring(0, raw.length()-1);
}
// strip off host portion if present and followed by path
split = raw.indexOf('/');
if (split > 0 && raw.substring(0, split).indexOf('.') > 0) {
raw = raw.substring(split+1);
}
// eliminate any invalid characters in name
StringBuffer buff = new StringBuffer();
int index = 0;
char chr = raw.charAt(0);
if (isAsciiAlpha(chr)) {
buff.append(chr);
index = 1;
} else {
buff.append('_');
}
boolean toupper = false;
while (index < raw.length()) {
chr = raw.charAt(index++);
if (isAsciiAlphaNum(chr)) {
if (toupper) {
chr = Character.toUpperCase(chr);
toupper = false;
}
buff.append(chr);
} else if (chr == '.') {
toupper = true;
} else if (chr == ':' || chr == '/') {
buff.append('_');
}
}
buff.append("Binding");
bindname = buff.toString();
}
// ensure uniqueness of the name
holder.setFileName(nameset.add(bindname) + ".xml");
}
// finish construction of this binding
holder.finish(Collections.EMPTY_LIST, Collections.EMPTY_LIST, m_nsRootUris, uridfltpref,
urifrcdpref);
// include within the root binding
IncludeElement include = new IncludeElement();
include.setIncludePath(holder.getFileName());
includes.add(include);
}
}
}
// add required namespace definitions to root binding
for (Iterator iter = m_nsRootUris.iterator(); iter.hasNext();) {
String uri = (String)iter.next();
if (!uri.equals(roothold.getNamespace())) {
roothold.getUsedNamespaces().add(uri);
}
}
// add namespace declarations needed by formats
for (Iterator iter = m_formats.iterator(); iter.hasNext();) {
FormatElement format = (FormatElement)iter.next();
QName qname = format.getQName();
if (qname != null) {
String uri = qname.getUri();
if (uri != null) {
roothold.getReferencedNamespaces().add(uri);
}
}
}
// finish building the root binding, using default prefixes where needed
roothold.finish(m_formats, includes, Collections.EMPTY_SET, uridfltpref, urifrcdpref);
// set the file name on the singleton or root binding
roothold.setFileName(rootname);
// set the binding name based on the file name
rootbind.setName(Utility.bindingFromFileName(rootname));
// mark the whole set now finished
m_finished = true;
// set the target package for code generation
rootbind.setTargetPackage(trgtpack);
return roothold;
}
/**
* Validate the constructed bindings. The {@link #configureFiles(String, String, List)} must be called before this
* method is called, in order to complete the root binding definition.
*
* @param root root binding holder (returned by {@link #configureFiles(String, String, List)})
* @param dir target directory for writing binding definitions
* @param vctx validation context to use
* @return true if valid, false if error
* @throws IOException
*/
public boolean validateBindings(BindingHolder root, File dir, ValidationContext vctx)
throws IOException {
BindingElement binding = root.getBinding();
binding.setBaseUrl(dir.toURI().toURL());
List keys = getKeys();
for (Iterator iter = keys.iterator(); iter.hasNext();) {
BindingHolder holder = (BindingHolder)m_objectBindings.get(iter.next());
if (holder != null && holder != root) {
String path = new File(dir, holder.getFileName()).toURI().toURL().toExternalForm();
if (binding.addIncludePath(path, false)) {
binding.addIncludeBinding(path, holder.getBinding());
}
}
}
vctx.setBindingRoot(binding);
binding.runValidation(vctx.isLookupSupported(), vctx);
return vctx.getErrorCount() == 0 && vctx.getFatalCount() == 0;
}
/**
* Write the bindings to supplied destination path. The {@link #configureFiles(String, String, List)} must be called
* before this method is called, in order to configure the file names and complete the root binding definition.
*
* @param dir target directory for writing binding definitions
* @throws JiBXException
* @throws IOException
*/
public void writeBindings(File dir) throws JiBXException, IOException {
IBindingFactory fact = BindingDirectory.getFactory("normal", BindingElement.class);
IMarshallingContext ictx = fact.createMarshallingContext();
ictx.setIndent(2);
List keys = getKeys();
for (Iterator iter = keys.iterator(); iter.hasNext();) {
BindingHolder holder = (BindingHolder)m_objectBindings.get(iter.next());
if (holder != null) {
File file = new File(dir, holder.getFileName());
ictx.setOutput(new FileOutputStream(file), null);
((IMarshallable)holder.getBinding()).marshal(ictx);
ictx.getXmlWriter().flush();
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/TreeContext.java 0000644 0001750 0001750 00000047624 11167465000 025505 0 ustar twerner twerner /*
Copyright (c) 2004-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.util.ArrayList;
import java.util.HashSet;
import org.jibx.binding.util.ObjectStack;
import org.jibx.util.IClass;
import org.jibx.util.IClassLocator;
/**
* Handles walking the tree structure of a binding model, tracking
* order-dependent state information collected along the way.
*
* @author Dennis M. Sosnoski
*/
public class TreeContext
{
/** Global definition context (outside of binding). */
private DefinitionContext m_globalContext;
/** Binding element model root (may be null, if not configured
by caller). */
private BindingElement m_bindingRoot;
/** Stack of items for parent hierarchy to current node in tree. */
private ObjectStack m_treeHierarchy;
/** Class locator set by environment code. */
private IClassLocator m_locator;
/** Set of elements to be skipped in walking tree. */
private HashSet m_skipSet;
/**
* Internal null constructor.
*/
private TreeContext() {}
/**
* Constructor.
*
* @param iloc class locator to be used
*/
public TreeContext(IClassLocator iloc) {
m_treeHierarchy = new ObjectStack();
m_locator = iloc;
m_skipSet = new HashSet();
}
/**
* Get a secondary context for the same tree as this instance. The secondary
* context shares the same skip set, context, and binding root as the
* original context. This allows activites invoked during the touring of the
* original tree to start subtours of their own part of the tree.
*
* @return new context linked to original context
*/
public TreeContext getChildContext() {
TreeContext child = new TreeContext();
child.m_bindingRoot = m_bindingRoot;
child.m_globalContext = m_globalContext;
child.m_locator = m_locator;
child.m_skipSet = m_skipSet;
child.m_treeHierarchy = new ObjectStack(m_treeHierarchy);
return child;
}
/**
* Set the global definition context. This context is external to the actual
* binding definition, providing defaults that can be overridden by values
* set within the actual binding.
*
* @param dctx global definition context
*/
public void setGlobalDefinitions(DefinitionContext dctx) {
m_globalContext = dctx;
}
/**
* Tour complete binding model tree. This tours the entire binding model,
* starting from the root binding element. Using this method automatically
* sets the root binding element for access by processing performed during
* the tour. It must be used for the binding element in order to
* handle included binding definitions properly.
*
* @param root binding element root of tree
* @param visitor target visitor for element notifications
*/
public void tourTree(BindingElement root, ModelVisitor visitor) {
// set up binding root reference for access during processing
BindingElement hold = m_bindingRoot;
m_bindingRoot = root;
// run the actual tour
tourTree((ElementBase)root, visitor);
// restore prior binding root reference
m_bindingRoot = hold;
}
/**
* Tour binding model tree. This recursively traverses the binding model
* tree rooted in the supplied element, notifying the visitor of each
* element visited during the traversal. Elements with fatal errors are
* skipped in processing, along with all child elements. The method may
* itself be called recursively.
*
* @param root node of tree to be toured
* @param visitor target visitor for element notifications
*/
public void tourTree(ElementBase root, ModelVisitor visitor) {
// check for fatal error on element
if (m_skipSet.contains(root)) {
return;
}
// visit the actual root of tree
boolean expand = false;
m_treeHierarchy.push(root);
switch (root.type()) {
case ElementBase.BINDING_ELEMENT:
expand = visitor.visit((BindingElement)root);
break;
case ElementBase.COLLECTION_ELEMENT:
expand = visitor.visit((CollectionElement)root);
break;
case ElementBase.FORMAT_ELEMENT:
visitor.visit((FormatElement)root);
break;
case ElementBase.INCLUDE_ELEMENT:
expand = visitor.visit((IncludeElement)root);
break;
case ElementBase.INPUT_ELEMENT:
expand = visitor.visit((InputElement)root);
break;
case ElementBase.MAPPING_ELEMENT:
if (root instanceof MappingElement) {
expand = visitor.visit((MappingElement)root);
} else {
expand = visitor.visit((PrecompiledMappingElement)root);
}
break;
case ElementBase.NAMESPACE_ELEMENT:
visitor.visit((NamespaceElement)root);
break;
case ElementBase.OUTPUT_ELEMENT:
expand = visitor.visit((OutputElement)root);
break;
case ElementBase.SPLIT_ELEMENT:
expand = visitor.visit((SplitElement)root);
break;
case ElementBase.STRUCTURE_ELEMENT:
expand = visitor.visit((StructureElement)root);
break;
case ElementBase.TEMPLATE_ELEMENT:
expand = visitor.visit((TemplateElement)root);
break;
case ElementBase.VALUE_ELEMENT:
visitor.visit((ValueElement)root);
break;
default:
throw new IllegalStateException
("Internal error: unknown element type");
}
// check for expansion needed
if (expand && !m_skipSet.contains(root)) {
if (root instanceof IncludeElement) {
// include just delegates to the included binding element
BindingElement binding = ((IncludeElement)root).getBinding();
if (binding != null) {
m_treeHierarchy.pop();
tourTree((ElementBase)binding, visitor);
m_treeHierarchy.push(root);
}
} else if (root instanceof NestingElementBase) {
// process each container child as root of own tree
ArrayList childs = null;
if (root instanceof MappingElement) {
childs = ((MappingElementBase)root).topChildren();
for (int i = 0; i < childs.size(); i++) {
tourTree((ElementBase)childs.get(i), visitor);
}
}
if (root instanceof BindingElement) {
childs = ((BindingElement)root).topChildren();
} else {
childs = ((NestingElementBase)root).children();
}
for (int i = 0; i < childs.size(); i++) {
tourTree((ElementBase)childs.get(i), visitor);
}
}
}
// exit the actual root of tree
switch (root.type()) {
case ElementBase.BINDING_ELEMENT:
visitor.exit((BindingElement)root);
break;
case ElementBase.COLLECTION_ELEMENT:
visitor.exit((CollectionElement)root);
break;
case ElementBase.INCLUDE_ELEMENT:
visitor.exit((IncludeElement)root);
break;
case ElementBase.INPUT_ELEMENT:
visitor.exit((InputElement)root);
break;
case ElementBase.MAPPING_ELEMENT:
if (root instanceof MappingElement) {
visitor.exit((MappingElement)root);
} else {
visitor.exit((PrecompiledMappingElement)root);
}
break;
case ElementBase.OUTPUT_ELEMENT:
visitor.exit((OutputElement)root);
break;
case ElementBase.SPLIT_ELEMENT:
visitor.exit((SplitElement)root);
break;
case ElementBase.STRUCTURE_ELEMENT:
visitor.exit((StructureElement)root);
break;
case ElementBase.TEMPLATE_ELEMENT:
visitor.exit((TemplateElement)root);
break;
case ElementBase.VALUE_ELEMENT:
visitor.exit((ValueElement)root);
break;
default:
break;
}
m_treeHierarchy.pop();
}
/**
* Get depth of nesting in binding.
*
* @return nesting depth
*/
public int getNestingDepth() {
return m_treeHierarchy.size();
}
/**
* Peek current element of hierarchy.
*
* @return current element
*/
protected ElementBase peekElement() {
return (ElementBase)m_treeHierarchy.peek();
}
/**
* Check if a component is being skipped due to a fatal error.
*
* @param obj component to be checked
* @return flag for component being skipped
*/
public boolean isSkipped(Object obj) {
return m_skipSet.contains(obj);
}
/**
* Add element to set to be skipped.
*
* @param skip
*/
protected void addSkip(Object skip) {
if (skip instanceof ElementBase) {
m_skipSet.add(skip);
}
}
/**
* Get root element of binding.
*
* @return root element of binding
* @throws IllegalStateException if no root element known
*/
public BindingElement getBindingRoot() {
if (m_bindingRoot == null) {
throw new IllegalStateException("No binding root defined");
} else {
return m_bindingRoot;
}
}
/**
* Set root element of binding. This should be called by the user if an
* element other than the binding element is going to be used as the root
* for a tour.
*
* @param root root element of binding
*/
public void setBindingRoot(BindingElement root) {
m_bindingRoot = root;
}
/**
* Get containing element. This is equivalent to the generation
* 1 parent, except that it checks for the case where there's
* no parent present.
*
* @return binding definition component for parent element, or
* null if no parent
*/
public NestingElementBase getParentElement() {
if (m_treeHierarchy.size() > 1) {
return (NestingElementBase)m_treeHierarchy.peek(1);
} else {
return null;
}
}
/**
* Get containing element at generation level. All except the zero-level
* containing element are guaranteed to be instances of {@link
* org.jibx.binding.model.NestingElementBase}.
*
* @param level generation level of parent
* @return binding definition component for parent at level
*/
public ElementBase getParentElement(int level) {
return (ElementBase)m_treeHierarchy.peek(level);
}
/**
* Get parent container information. This returns the innermost containing
* binding component which refers to an object.
*
* @return innermost containing element referencing bound object
*/
public ContainerElementBase getParentContainer() {
int index = 1;
while (index < m_treeHierarchy.size()) {
NestingElementBase nest =
(NestingElementBase)m_treeHierarchy.peek(index++);
if (nest instanceof ContainerElementBase) {
return (ContainerElementBase)nest;
}
}
throw new IllegalStateException("Internal error: no container");
}
/**
* Get parent container with linked object. This returns the innermost
* containing binding component which defines a context object.
*
* @return innermost containing element defining a context object
*/
public ContainerElementBase getContextObject() {
int index = 1;
while (index < m_treeHierarchy.size()) {
NestingElementBase nest =
(NestingElementBase)m_treeHierarchy.peek(index++);
if (nest instanceof ContainerElementBase) {
ContainerElementBase contain = (ContainerElementBase)nest;
if (contain.hasObject()) {
return contain;
}
}
}
throw new IllegalStateException("Internal error: no context object");
}
/**
* Check if binding supports input.
*
* @return true if input binding, false if not
*/
public boolean isInBinding() {
return m_bindingRoot == null ? true : m_bindingRoot.isInBinding();
}
/**
* Check if binding supports output.
*
* @return true if output binding, false if not
*/
public boolean isOutBinding() {
return m_bindingRoot == null ? true : m_bindingRoot.isOutBinding();
}
/**
* Get innermost containing definition context.
*
* @return innermost definition context containing this element
*/
public DefinitionContext getDefinitions() {
int index = 1;
while (index < m_treeHierarchy.size()) {
NestingElementBase nest =
(NestingElementBase)m_treeHierarchy.peek(index++);
if (nest.getDefinitions() != null) {
return nest.getDefinitions();
}
}
if (m_globalContext == null) {
throw new IllegalStateException
("Internal error: no definition context");
} else {
return m_globalContext;
}
}
/**
* Get definition context for innermost nesting element. If the context for
* this element isn't already defined it's created by the call.
*
* @return definition context for innermost nesting element
*/
public DefinitionContext getCurrentDefinitions() {
NestingElementBase parent = getParentElement();
DefinitionContext dctx = parent.getDefinitions();
if (dctx == null) {
dctx = new DefinitionContext(getDefinitions());
parent.setDefinitions(dctx);
}
return dctx;
}
/**
* Get definition context for innermost nesting element for use by a
* format (or namespace). If the context for this element
* isn't already defined it's created by the call, along with the contexts
* for any containing elements. This is ugly, but necessary to keep the tree
* structure of contexts from getting split when other items are added by
* the registration pass (since the formats are registered in the
* prevalidation pass).
*
* @return definition context for innermost nesting element
*/
public DefinitionContext getFormatDefinitions() {
NestingElementBase parent = getParentElement();
DefinitionContext dctx = parent.getDefinitions();
if (dctx == null) {
// scan to find innermost nesting with context
int index = 1;
DefinitionContext pctx = null;
while (++index < m_treeHierarchy.size()) {
NestingElementBase nest =
(NestingElementBase)m_treeHierarchy.peek(index);
pctx = nest.getDefinitions();
if (pctx != null) {
break;
}
}
// add contexts for all ancestors to level
while (index >= 2) {
dctx = new DefinitionContext(pctx);
NestingElementBase nest =
(NestingElementBase)m_treeHierarchy.peek(--index);
nest.setDefinitions(dctx);
pctx = dctx;
}
}
return dctx;
}
/**
* Check if class lookup is supported. If this returns false,
* lookup methods return only place holder class information.
*
* @return true if class lookup supported, false
* if only place holder information returned
*/
public boolean isLookupSupported() {
return m_locator.isLookupSupported();
}
/**
* Get class information. Finds a class by name using the class locator
* configured by the environment code.
*
* @param name fully-qualified name of class to be found
* @return class information, or null if class not found
*/
public IClass getClassInfo(String name) {
return m_locator.getClassInfo(name);
}
/**
* Get required class information. Finds a class by name using the class
* locator configured by the environment code. If the class cannot be found
* a runtime exception is thrown.
*
* @param name fully-qualified name of class to be found
* @return class information
*/
public IClass getRequiredClassInfo(String name) {
IClass iclas = m_locator.getClassInfo(name);
if (iclas == null) {
throw new IllegalStateException("Internal error: class " + name +
" cannot be found");
} else {
return iclas;
}
}
/**
* Push node on tree. This is provided for use during validation, when the
* context may be changed by recursive checks outside the normal tree
* traversal.
*
* @param node
*/
public void pushNode(ElementBase node) {
m_treeHierarchy.push(node);
}
/**
* Pop node from tree. This is provided for use during validation, when the
* context may be changed by recursive checks outside the normal tree
* traversal.
*
* @return node
*/
public ElementBase popNode() {
return (ElementBase)m_treeHierarchy.pop();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/IncludeElement.java 0000644 0001750 0001750 00000013526 11424461612 026131 0 ustar twerner twerner /*
Copyright (c) 2004-2010, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.io.IOException;
import java.net.URL;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.util.ClasspathUrlExtender;
import org.jibx.util.StringArray;
/**
* Model component for include element of binding definition. During
* prevalidation this reads the included binding definition. All further
* processing of the included components needs to be handled directly by the
* tree walking code in {@link org.jibx.binding.model.TreeContext}, since the
* components of the included binding need to be treated as though they were
* direct children of the container of this element (and accessed in the
* appropriate order).
*
* @author Dennis M. Sosnoski
*/
public class IncludeElement extends NestingElementBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "path", "precompiled" });
/** Path to included binding definition. */
private String m_includePath;
/** Included binding precompiled flag. */
private boolean m_precompiled;
/** Object model for included binding. */
private BindingElement m_binding;
/**
* Constructor.
*/
public IncludeElement() {
super(INCLUDE_ELEMENT);
}
/**
* Set path to included binding.
*
* @param path
*/
public void setIncludePath(String path) {
m_includePath = path;
}
/**
* Get path to included binding.
*
* @return path
*/
public String getIncludePath() {
return m_includePath;
}
/**
* Get the included binding model. This call is only valid after
* prevalidation.
*
* @return binding element, or null if redundant include
*/
public BindingElement getBinding() {
return m_binding;
}
/**
* Check if precompiled binding.
*
* @return true if precompiled, false if not
*/
public boolean isPrecompiled() {
return m_precompiled;
}
/**
* Set precompiled binding flag.
*
* @param precomp
*/
public void setPrecompiled(boolean precomp) {
m_precompiled = precomp;
}
//
// Validation methods
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
* @exception JiBXException on unmarshalling error
*/
private void preSet(IUnmarshallingContext uctx) throws JiBXException {
validateAttributes(uctx, s_allowedAttributes);
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#prevalidate(org.jibx.binding.model.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
if (m_includePath == null) {
vctx.addFatal("No include path specified");
} else {
try {
// locate the innermost binding element
int limit = vctx.getNestingDepth();
BindingElement binding = null;
for (int i = 1; i < limit; i++) {
ElementBase parent = vctx.getParentElement(i);
if (parent instanceof BindingElement) {
binding = (BindingElement)parent;
break;
}
}
if (binding == null) {
throw new JiBXException("No binding element found");
}
// access the included binding as input stream
URL base = binding.getBaseUrl();
URL url = ClasspathUrlExtender.buildURL(base, m_includePath);
String path = url.toExternalForm();
BindingElement root = vctx.getBindingRoot();
if (root.addIncludePath(path, m_precompiled)) {
m_binding = root.getIncludeBinding(url, binding, vctx);
}
} catch (JiBXException e) {
vctx.addFatal("Error unmarshalling included binding '" + m_includePath + "': " + e.getMessage());
} catch (IOException e) {
vctx.addFatal("Error accessing included binding with path \"" +
m_includePath + "\": " + e.getMessage());
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/ClassUtils.java 0000644 0001750 0001750 00000024633 11062041116 025312 0 ustar twerner twerner /*
Copyright (c) 2004-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.util.HashMap;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
/**
* Utilities for working with class, field, or method information.
*
* @author Dennis M. Sosnoski
*/
public class ClassUtils
{
/** Map for primitive type signature variants. */
private static HashMap s_variantMap = new HashMap();
/** Map for signatures corresponding to class names. */
private static HashMap s_signatureMap = new HashMap();
static {
// initialize primitive type variants
s_variantMap.put("boolean", new String[] { "Z" });
s_variantMap.put("byte", new String[] { "B", "S", "I" });
s_variantMap.put("char", new String[] { "C", "I" });
s_variantMap.put("double", new String[] { "D" });
s_variantMap.put("float", new String[] { "F" });
s_variantMap.put("int", new String[] { "I" });
s_variantMap.put("long", new String[] { "J" });
s_variantMap.put("short", new String[] { "S", "I" });
s_variantMap.put("void", new String[] { "V" });
// initialize signatures for primitive types
s_signatureMap.put("boolean", "Z");
s_signatureMap.put("byte", "B");
s_signatureMap.put("char", "C");
s_signatureMap.put("double", "D");
s_signatureMap.put("float", "F");
s_signatureMap.put("int", "I");
s_signatureMap.put("long", "J");
s_signatureMap.put("short", "S");
s_signatureMap.put("void", "V");
}
/**
* Check if type name is a primitive.
*
* @param type
* @return true if a primitive, false if not
*/
public static boolean isPrimitive(String type) {
return s_variantMap.get(type) != null;
}
/**
* Get virtual method by fully qualified name. This splits the class
* name from the method name, finds the class, and then tries to find a
* matching method name in that class or a superclass.
*
* @param name fully qualified class and method name
* @param sigs possible method signatures
* @param vctx validation context (used for class lookup)
* @return information for the method, or null if not found
*/
public static IClassItem findVirtualMethod(String name, String[] sigs,
ValidationContext vctx) {
// get the class containing the method
int split = name.lastIndexOf('.');
String cname = name.substring(0, split);
String mname = name.substring(split+1);
IClass iclas = vctx.getClassInfo(cname);
if (iclas != null) {
// find the method in class or superclass
for (int i = 0; i < sigs.length; i++) {
IClassItem method = iclas.getMethod(mname, sigs[i]);
if (method != null) {
return method;
}
}
}
return null;
}
/**
* Get static method by fully qualified name. This splits the class
* name from the method name, finds the class, and then tries to find a
* matching method name in that class.
*
* @param name fully qualified class and method name
* @param sigs possible method signatures
* @param vctx validation context (used for class lookup)
* @return information for the method, or null if not found
*/
public static IClassItem findStaticMethod(String name, String[] sigs,
ValidationContext vctx) {
// get the class containing the method
int split = name.lastIndexOf('.');
if (split > 0) {
String cname = name.substring(0, split);
String mname = name.substring(split+1);
IClass iclas = vctx.getClassInfo(cname);
if (iclas != null) {
// find the method in class or superclass
for (int i = 0; i < sigs.length; i++) {
IClassItem method = iclas.getStaticMethod(mname, sigs[i]);
if (method != null) {
return method;
}
}
}
}
return null;
}
/**
* Get all variant signatures for a fully qualified class name. The
* returned array gives all signatures (for interfaces or classes) which
* instances of the class can match.
*
* @param name fully qualified class name
* @param vctx validation context (used for class lookup)
* @return possible signature variations for instances of the class
*/
public static String[] getSignatureVariants(String name,
ValidationContext vctx) {
Object obj = s_variantMap.get(name);
if (obj == null) {
IClass iclas = vctx.getRequiredClassInfo(name);
return iclas.getInstanceSigs();
} else {
return (String[])obj;
}
}
/**
* Gets the signature string corresponding to a type. The base for the type
* may be a primitive or class name, and may include trailing array
* brackets.
*
* @param type type name
* @return signature string for type
*/
public static String getSignature(String type) {
//. check if already built signature for this type
String sig = (String)s_signatureMap.get(type);
if (sig == null) {
// check if this is an array type
int dim = 0;
int split = type.indexOf('[');
if (split >= 0) {
// count pairs of array brackets
int mark = split;
while ((type.length()-mark) >= 2) {
if (type.charAt(mark) == '[' ||
type.charAt(mark+1) == ']') {
dim++;
mark += 2;
} else {
throw new IllegalArgumentException
("Invalid type name " + type);
}
}
// make sure only bracket pairs at end
if (mark < type.length()) {
throw new IllegalArgumentException("Invalid type name " +
type);
}
// see if signature for base object type needs to be added
String cname = type.substring(0, split);
String base = (String)s_signatureMap.get(cname);
if (base == null) {
// add base type signature to map
base = "L" + cname.replace('.', '/') + ';';
s_signatureMap.put(cname, base);
}
// prepend appropriate number of
StringBuffer buff = new StringBuffer(dim + base.length());
for (int i = 0; i < dim; i++) {
buff.append('[');
}
buff.append(base);
sig = buff.toString();
} else {
// define signature for ordinary object type
sig = "L" + type.replace('.', '/') + ';';
}
// add signature definition to map
s_signatureMap.put(type, sig);
}
// return signature for type
return sig;
}
/**
* Check if a value of one type can be directly assigned to another type.
* This is basically the equivalent of the instanceof operator, but with
* application to primitive types as well as object types.
*
* @param from fully qualified class name of initial type
* @param to fully qualified class name of assignment type
* @param vctx validation context (used for class lookup)
* @return true if assignable, false if not
*/
public static boolean isAssignable(String from, String to,
ValidationContext vctx) {
// always assignable if the two are the same
if (from.equals(to)) {
return true;
} else {
// try direct lookup for primitive types
Object fobj = s_variantMap.get(from);
Object tobj = s_variantMap.get(to);
if (fobj == null && tobj == null) {
// find the actual class information
IClass fclas = vctx.getRequiredClassInfo(from);
IClass tclas = vctx.getRequiredClassInfo(to);
// assignable if from type has to as a possible signature
String[] sigs = fclas.getInstanceSigs();
String match = tclas.getSignature();
for (int i = 0; i < sigs.length; i++) {
if (match.equals(sigs[i])) {
return true;
}
}
return false;
} else if (fobj != null && tobj != null) {
// assignable if from type has to as a possible signature
String[] fsigs = (String[])fobj;
String[] tsigs = (String[])tobj;
if (tsigs.length == 1) {
for (int i = 0; i < fsigs.length; i++) {
if (fsigs[i] == tsigs[0]) {
return true;
}
}
}
return false;
} else {
// primitive and object types never assignable
return false;
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/NestingAttributes.java 0000644 0001750 0001750 00000007377 11062041124 026707 0 ustar twerner twerner /*
Copyright (c) 2004-2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import org.jibx.runtime.EnumSet;
import org.jibx.util.StringArray;
/**
* Model component for nesting attribute group in binding definition.
*
* @author Dennis M. Sosnoski
*/
public class NestingAttributes extends AttributeBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "value-style" });
//
// Value set information
public static final int ATTRIBUTE_STYLE = 0;
public static final int ELEMENT_STYLE = 1;
/*package*/ static final EnumSet s_styleEnum = new EnumSet(ATTRIBUTE_STYLE,
new String[] { "attribute", "element" });
//
// Instance data
/** Supplied style name. */
private String m_styleName;
/** Actual selected style. */
private int m_styleIndex;
/**
* Get style string value.
*
* @return style string value (null if undefined at this level)
*/
public String getStyleName() {
return m_styleName;
}
/**
* Get style value. This method is only usable after a call to {@link
* #validate}.
*
* @return style value
*/
public int getStyle() {
return m_styleIndex;
}
/**
* Set style name.
*
* @param name style name (null to undefine style at this
* level)
*/
public void setStyleName(String name) {
m_styleName = name;
}
//
// Overrides of base class methods
/* (non-Javadoc)
* @see org.jibx.binding.model.AttributeBase#prevalidate(org.jibx.binding.model.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
if (m_styleName == null) {
NestingElementBase parent = vctx.getParentElement();
if (parent == null) {
m_styleIndex = ELEMENT_STYLE;
} else {
m_styleIndex = parent.getDefaultStyle();
}
} else {
int style = s_styleEnum.getValue(m_styleName);
if (style < 0) {
vctx.addError("Value \"" + m_styleName +
"\" is not a valid style");
} else {
m_styleIndex = style;
}
}
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/InputElement.java 0000644 0001750 0001750 00000003555 10210703670 025641 0 ustar twerner twerner /*
Copyright (c) 2004-2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
/**
* Model component for input element of binding definition. This is only
* used for structuring purposes and doesn't require any actual processing.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class InputElement extends NestingElementBase
{
/**
* Constructor.
*/
public InputElement() {
super(INPUT_ELEMENT);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/ClassHierarchyContext.java 0000644 0001750 0001750 00000020417 11525244530 027502 0 ustar twerner twerner /*
Copyright (c) 2005-2009, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
import org.jibx.util.IClass;
/**
* Context for components using a hierarchy of definitions based on class type.
* This is used to track conversion definitions in the form of format and
* template elements. The access methods take the different levels of
* nesting into account, automatically delegating to the containing context (if
* defined) when a lookup fails.
*
* @author Dennis M. Sosnoski
*/
public class ClassHierarchyContext
{
/** Link to containing context. */
private final ClassHierarchyContext m_outerContext;
/** Map from type name to binding component. */
private HashMap m_typeToComponentMap;
/** Set of compatible type names. */
private HashSet m_compatibleTypeSet;
/** Map from format names to String conversions (lazy create). */
private HashMap m_nameToComponentMap;
/**
* Constructor.
*
* @param outer containing context (null if at root of tree)
*/
protected ClassHierarchyContext(ClassHierarchyContext outer) {
m_outerContext = outer;
m_typeToComponentMap = new HashMap();
m_compatibleTypeSet = new HashSet();
m_nameToComponentMap = new HashMap();
}
/**
* Get containing context.
*
* @return containing context information (null if at root of
* tree)
*/
public ClassHierarchyContext getContaining() {
return m_outerContext;
}
/**
* Accumulate all the interfaces implemented (both directly and indirectly)
* by a class.
*
* @param clas
* @param intfset set of interfaces
*/
private void accumulateInterfaces(IClass clas, Set intfset) {
String[] interfaces = clas.getInterfaces();
for (int i = 0; i < interfaces.length; i++) {
String name = interfaces[i];
if (!intfset.contains(name)) {
intfset.add(name);
IClass iclas = clas.getLocator().getClassInfo(name);
if (iclas != null) {
accumulateInterfaces(iclas, intfset);
}
}
}
}
/**
* Add typed component to set defined at this level. This associates the
* component with the type for class hierarchy-based lookups.
*
* @param clas class information to be associated with component
* @param comp definition component to be added
* @param vctx validation context in use
*/
public void addTypedComponent(IClass clas, ElementBase comp,
ValidationContext vctx) {
String type = clas.getName();
if (m_typeToComponentMap.put(type, comp) == null) {
// new type, add all interfaces and supertypes to compatible set
IClass sclas = clas;
do {
m_compatibleTypeSet.add(sclas.getName());
if (vctx.isLookupSupported()) {
accumulateInterfaces(sclas, m_compatibleTypeSet);
}
} while ((sclas = sclas.getSuperClass()) != null);
} else {
vctx.addError("Duplicate conversion defined for type " + type,
comp);
}
}
/**
* Add named component to set defined at this level.
* TODO: Make this use qname instead of text
*
* @param label name to be associated with component
* @param comp definition component to be added
* @param vctx validation context in use
*/
public void addNamedComponent(String label, ElementBase comp,
ValidationContext vctx) {
if (m_nameToComponentMap.put(label, comp) != null) {
if (label.startsWith("{}")) {
label = label.substring(2);
}
vctx.addError("Duplicate name " + label, comp);
}
}
/**
* Get specific binding component for type. Looks for an exact match on the
* type name, checking the containing definitions if a matching component is
* not found at this level.
*
* @param name fully qualified class name to be converted
* @return binding component for class, or null if not
* found
*/
public ElementBase getSpecificComponent(String name) {
ElementBase comp = null;
if (m_typeToComponentMap != null) {
comp = (ElementBase)m_typeToComponentMap.get(name);
}
if (comp == null && m_outerContext != null) {
comp = m_outerContext.getSpecificComponent(name);
}
return comp;
}
/**
* Get named binding component definition. Finds the component with the
* supplied name, checking the containing definitions if the component is
* not found at this level.
*
* @param name component name to be found
* @return binding component with name, or null if not
* found
*/
public ElementBase getNamedComponent(String name) {
ElementBase comp = null;
if (m_nameToComponentMap != null) {
comp = (ElementBase)m_nameToComponentMap.get(name);
}
if (comp == null && m_outerContext != null) {
comp = m_outerContext.getNamedComponent(name);
}
return comp;
}
/**
* Get best binding component for class. Finds the component based on a
* fully qualified class name. If a specific component for the actual
* class is not found (either in this or a containing level) this returns
* the most specific superclass component.
*
* @param clas information for target class
* @return binding component definition for class, or null if
* none found
*/
public ElementBase getMostSpecificComponent(IClass clas) {
ElementBase comp = getSpecificComponent(clas.getName());
while (comp == null) {
IClass sclas = clas.getSuperClass();
if (sclas == null) {
break;
}
clas = sclas;
comp = getSpecificComponent(clas.getName());
}
return comp;
}
/**
* Checks if a class is compatible with one or more components. If a
* specific component for the actual class is not found (either in this or a
* containing level) this checks for components that handle subclasses or
* implementations of the class.
*
* @param clas information for target class
* @return true if compatible type, false if not
*/
public boolean isCompatibleType(IClass clas) {
if (m_compatibleTypeSet.contains(clas.getName())) {
return true;
} else if (m_outerContext != null) {
return m_outerContext.isCompatibleType(clas);
} else {
return false;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/PropertyAttributes.java 0000644 0001750 0001750 00000051104 11474530752 027130 0 ustar twerner twerner /*
Copyright (c) 2004-2010, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.util.ArrayList;
import org.jibx.runtime.EnumSet;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
import org.jibx.util.StringArray;
/**
* Model component for property attribute group in binding definition.
*
* @author Dennis M. Sosnoski
*/
public class PropertyAttributes extends AttributeBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "field", "flag-method", "get-method",
"set-method", "test-method", "type", "usage" });
// recognized test-method signatures.
private static final String[] TEST_METHOD_SIGNATURES =
{
"(Lorg/jibx/runtime/IMarshallingContext;)Z",
"()Z"
};
// recognized flag-method signatures.
private static final String[] FLAG_METHOD_SIGNATURES =
{
"(ZLorg/jibx/runtime/IMarshallingContext;)",
"(Z)"
};
// recognized get-method signatures.
private static final String[] GET_METHOD_SIGNATURES =
{
"(Lorg/jibx/runtime/IMarshallingContext;)",
"()"
};
//
// Value set information
public static final int REQUIRED_USAGE = 0;
public static final int OPTIONAL_USAGE = 1;
public static final int OPTIONAL_IN_USAGE = 2;
public static final int OPTIONAL_OUT_USAGE = 3;
private static final EnumSet s_usageEnum = new EnumSet(REQUIRED_USAGE,
new String[] { "required", "optional", "opt-in", "opt-out" });
//
// Instance data.
/** Usage type code. */
private int m_usage;
/** Usage name. */
private String m_usageName = s_usageEnum.getName(REQUIRED_USAGE);
/** Property type name. */
private String m_declaredType;
/** Property field name. */
private String m_fieldName;
/** Test method name. */
private String m_testName;
/** Flag method name. */
private String m_flagName;
/** Get method name. */
private String m_getName;
/** Set method name. */
private String m_setName;
/** Type for value loaded on stack. */
private IClass m_getType;
/** Type for value stored from stack. */
private IClass m_setType;
/** Property type information. */
private IClass m_type;
/** Property field information. */
private IClassItem m_fieldItem;
/** Test method information. */
private IClassItem m_testItem;
/** Flag method information. */
private IClassItem m_flagItem;
/** Get method information. */
private IClassItem m_getItem;
/** Set method information. */
private IClassItem m_setItem;
/** Flag for no actual property definition. */
private boolean m_isImplicit;
/**
* Get usage name.
*
* @return usage name
*/
public String getUsageName() {
return s_usageEnum.getName(m_usage);
}
/**
* Get usage value. This method is only usable after a call to {@link
* #prevalidate(ValidationContext)}.
*
* @return usage value
*/
public int getUsage() {
return m_usage;
}
/**
* Set usage name.
*
* @param name usage name
*/
public void setUsageName(String name) {
m_usageName = name;
}
/**
* Set usage value.
*
* @param use value
*/
public void setUsage(int use) {
m_usage = use;
m_usageName = s_usageEnum.getName(use);
}
/**
* Check if property is defined. This method is only usable after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return true if property defined, false if not
*/
public boolean hasProperty() {
return !m_isImplicit && m_type != null;
}
/**
* Get declared type name.
*
* @return declared type name (or null if none)
*/
public String getDeclaredType() {
return m_declaredType;
}
/**
* Set declared type name.
*
* @param type declared type name (or null if none)
*/
public void setDeclaredType(String type) {
m_declaredType = type;
}
/**
* Get field name.
*
* @return field name (or null if none)
*/
public String getFieldName() {
return m_fieldName;
}
/**
* Get field information. This method is only usable after a call to {@link
* #prevalidate(ValidationContext)}.
*
* @return field information (or null if none)
*/
public IClassItem getField() {
return m_fieldItem;
}
/**
* Set field name.
*
* @param field field name (or null if none)
*/
public void setFieldName(String field) {
m_fieldName = field;
}
/**
* Get test method name.
*
* @return test method name (or null if none)
*/
public String getTestName() {
return m_testName;
}
/**
* Get test method information. This method is only usable after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return test method information (or null if none)
*/
public IClassItem getTest() {
return m_testItem;
}
/**
* Set test method name.
*
* @param test test method name (or null if none)
*/
public void setTestName(String test) {
m_testName = test;
}
/**
* Get flag method name.
*
* @return flag method name (or null if none)
*/
public String getFlagName() {
return m_flagName;
}
/**
* Get flag method information. This method is only usable after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return flag method information (or null if none)
*/
public IClassItem getFlag() {
return m_flagItem;
}
/**
* Set flag method name.
*
* @param flag flag method name (or null if none)
*/
public void setFlagName(String flag) {
m_flagName = flag;
}
/**
* Get get method name.
*
* @return get method name (or null if none)
*/
public String getGetName() {
return m_getName;
}
/**
* Get get method information. This method is only usable after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return get method information (or null if none)
*/
public IClassItem getGet() {
return m_getItem;
}
/**
* Get type for value loaded to stack. This method is only usable after a
* call to {@link #prevalidate(ValidationContext)}.
*
* @return get value type (or null if none)
*/
public IClass getGetType() {
return m_getType;
}
/**
* Set get method name.
*
* @param get get method name (or null if none)
*/
public void setGetName(String get) {
m_getName = get;
}
/**
* Get set method name.
*
* @return set method name (or null if none)
*/
public String getSetName() {
return m_setName;
}
/**
* Get set method information. This method is only usable after a call to
* {@link #prevalidate(ValidationContext)}.
*
* @return set method information (or null if none)
*/
public IClassItem getSet() {
return m_setItem;
}
/**
* Get type for value stored from stack. This method is only usable after a
* call to {@link #prevalidate(ValidationContext)}.
*
* @return set value type (or null if none)
*/
public IClass getSetType() {
return m_setType;
}
/**
* Set set method name.
*
* @param set set method name (or null if none)
*/
public void setSetName(String set) {
m_setName = set;
}
/**
* Get type information. This method is only usable after a call to {@link
* #prevalidate(ValidationContext)}.
*
* @return type information (or null if none)
*/
public IClass getType() {
return m_type;
}
/**
* Check if empty property definition. Empty property definitions occur
* because every collection, structure, and value
* element has associated property attributes but these may not actually
* reference a property (when using the containing object). This call is
* only meaningful after prevalidation.
*
* @return true if implicit property, false if not
*/
public boolean isImplicit() {
return m_isImplicit;
}
/**
* Check if property consists only of flag. This call is only meaningful
* after prevalidation.
*
* @return true if flag property, false if not
*/
public boolean isFlagOnly() {
return m_flagItem != null && m_testItem != null;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.AttributeBase#prevalidate(org.jibx.binding.model.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check usage value
if (m_usageName != null) {
m_usage = s_usageEnum.getValue(m_usageName);
if (m_usage < 0) {
vctx.addError("Value \"" + m_usageName +
"\" is not a valid choice for usage");
}
} else {
m_usage = vctx.getParentElement().getDefaultStyle();
}
// handle basic lookups and checks
ContainerElementBase parent = vctx.getParentContainer();
IClass cobj = parent.getChildObjectType();
String dtype = null;
String gtype = null;
String stype = null;
boolean err = false;
m_isImplicit = true;
if (m_fieldName != null) {
// field means this is real (not implicit)
m_isImplicit = false;
if (vctx.isLookupSupported()) {
// look up the field information
m_fieldItem = cobj.getField(m_fieldName);
if (m_fieldItem == null) {
vctx.addFatal("Nonstatic field " + m_fieldName +
" not found in class " + cobj.getName());
err = true;
} else {
dtype = gtype = stype = m_fieldItem.getTypeName();
}
}
}
if (m_testName != null) {
// make sure only used with optional
if (m_usage == REQUIRED_USAGE) {
vctx.addError("test-method can only be used with optional property");
} else if (vctx.isLookupSupported()) {
// look up the method information
m_testItem = cobj.getMethod(m_testName, TEST_METHOD_SIGNATURES);
if (m_testItem == null) {
vctx.addError("Nonstatic test-method " + m_testName +
" not found in class " + cobj.getName());
}
}
}
if (m_flagName != null) {
// flag-method means this is real (not implicit)
m_isImplicit = false;
stype = "java.lang.Object";
if (m_testName != null) {
gtype = stype;
}
if (vctx.isLookupSupported()) {
// look up the method information
m_flagItem = cobj.getMethod(m_flagName, FLAG_METHOD_SIGNATURES);
if (m_flagItem == null) {
vctx.addError("Nonstatic flag-method " + m_flagName +
" not found in class " + cobj.getName());
}
}
}
if (m_getName != null) {
// get-method means this is real (not implicit)
m_isImplicit = false;
if (vctx.isLookupSupported()) {
// look up the get method by name (no overload possible)
m_getItem = cobj.getMethod(m_getName, GET_METHOD_SIGNATURES);
if (m_getItem == null) {
vctx.addFatal("Nonstatic get-method " + m_getName +
" not found in class " + cobj.getName());
err = true;
} else {
gtype = m_getItem.getTypeName();
if (dtype == null) {
dtype = gtype;
}
}
}
// check for only get-method supplied when both directions needed
if (vctx.isInBinding() && m_fieldName == null &&
m_setName == null) {
vctx.addError("Need field or set-method for input handling");
}
}
if (m_setName != null) {
// set-method means this is real (not implicit)
m_isImplicit = false;
if (vctx.isLookupSupported()) {
// need to handle overloads, so generate possible signatures
ArrayList sigs = new ArrayList();
if (m_getItem != null) {
String psig = ClassUtils.getSignature(gtype);
sigs.add("(" + psig +
"Lorg/jibx/runtime/IUnmarshallingContext;" + ")V");
sigs.add("(" + psig + ")V");
}
if (m_declaredType != null) {
String psig = ClassUtils.getSignature(m_declaredType);
sigs.add("(" + psig +
"Lorg/jibx/runtime/IUnmarshallingContext;" + ")V");
sigs.add("(" + psig + ")V");
}
if (m_fieldItem != null) {
String psig = m_fieldItem.getSignature();
sigs.add("(" + psig +
"Lorg/jibx/runtime/IUnmarshallingContext;" + ")V");
sigs.add("(" + psig + ")V");
}
sigs.add
("(Ljava/lang/Object;Lorg/jibx/runtime/IUnmarshallingContext;)V");
sigs.add("(Ljava/lang/Object;)V");
// match any of the possible signatures
m_setItem = cobj.getMethod(m_setName,
(String[])sigs.toArray(new String[0]));
if (m_setItem == null) {
// nothing known about signature, try anything by name
m_setItem = cobj.getMethod(m_setName, "");
if (m_setItem != null) {
if (!m_setItem.getTypeName().equals("void") ||
m_setItem.getArgumentCount() > 2) {
m_setItem = null;
} else if (m_setItem.getArgumentCount() == 2) {
String xtype = m_setItem.getArgumentType(1);
if (!"org.jibx.runtime.IUnmarshallingContext".equals(xtype)) {
m_setItem = null;
}
}
}
if (m_setItem != null) {
// make sure resulting type is compatible
String type = m_setItem.getArgumentType(0);
if (m_declaredType != null &&
!ClassUtils.isAssignable(m_declaredType, type, vctx)) {
m_setItem = null;
} else if (dtype != null &&
!ClassUtils.isAssignable(type, dtype, vctx)) {
m_setItem = null;
} else if (gtype != null &&
!ClassUtils.isAssignable(type, gtype, vctx)) {
m_setItem = null;
}
if (m_setItem != null) {
dtype = type;
}
}
}
// check set-method found
if (m_setItem == null) {
vctx.addFatal("Nonstatic set-method " + m_setName +
" with argument of appropriate type not found in class " +
cobj.getName());
err = true;
} else {
stype = m_setItem.getArgumentType(0);
if (dtype == null) {
dtype = stype;
}
}
}
// check for only set-method supplied when both directions needed
if (vctx.isOutBinding() && m_fieldName == null &&
m_getName == null) {
vctx.addError("Need field or get-method for output handling");
}
}
// set the property type information
String tname = m_declaredType;
if (tname == null) {
tname = dtype;
if (tname == null) {
tname = cobj.getName();
}
} else if (dtype == null) {
dtype = gtype = stype = tname;
}
m_type = vctx.getClassInfo(tname);
if (m_type == null) {
vctx.addFatal("Unable to load class " + tname);
} else if (vctx.getContextObject() instanceof CollectionElement) {
// forbid access specifications for child of collection
if (m_fieldName != null || m_getName != null || m_setName != null) {
vctx.addWarning("Property access attributes (field, " +
"get-method, set-method) ignored for collection item");
}
} else if (!err && !m_isImplicit && vctx.isLookupSupported()) {
// check that type information is consistent
boolean valid = true;
// require access specifications for child of non-collection
if (vctx.isInBinding()) {
if (stype == null) {
vctx.addError("No way to set property value");
stype = "java.lang.Object";
} else {
valid = ClassUtils.isAssignable(tname, stype, vctx) ||
ClassUtils.isAssignable(stype, tname, vctx);
}
m_setType = vctx.getClassInfo(stype);
}
if (gtype == null) {
if (vctx.isOutBinding()) {
vctx.addError("No way to get property value");
m_getType = vctx.getClassInfo("java.lang.Object");
}
} else {
if (valid) {
valid = ClassUtils.isAssignable(tname, gtype, vctx) ||
ClassUtils.isAssignable(gtype, tname, vctx);
}
m_getType = vctx.getClassInfo(gtype);
}
if (!valid) {
vctx.addError("Incompatible types used in property definition");
}
}
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/DefinitionContext.java 0000644 0001750 0001750 00000063755 11524076670 026711 0 ustar twerner twerner /*
Copyright (c) 2004-2011, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.util.ArrayList;
import java.util.HashMap;
import org.jibx.runtime.Utility;
import org.jibx.util.IClass;
/**
* Definition context information. This is used to track definitions of items
* that can be referenced by other items. The contexts are nested, so that names
* not found in a context may be defined by a containing context. The access
* methods take this into account, automatically delegating to the containing
* context (if defined) when a lookup fails.
*
* @author Dennis M. Sosnoski
*/
public class DefinitionContext
{
/** Link to containing definition context. */
private final DefinitionContext m_outerContext;
/** Namespace used by default at this level for attributes. */
private NamespaceElement m_attributeDefault;
/** Namespace used by default at this level for elements. */
private NamespaceElement m_elementDefault;
/** Namespaces defined at level (lazy create). */
private ArrayList m_namespaces;
/** Mapping from prefix to namespace definition (lazy create). */
private HashMap m_prefixMap;
/** Mapping from URI to namespace definition (lazy create). */
private HashMap m_uriMap;
/** Map from element names to mappings defined at level (lazy create). */
private HashMap m_mappingMap;
/** Class hierarchy context for format definitions (lazy create). */
private ClassHierarchyContext m_formatContext;
/** Class hierarchy context for template definitions (lazy create). */
private ClassHierarchyContext m_templateContext;
/** Named binding components (lazy create). */
private HashMap m_namedStructureMap;
/**
* Constructor.
*
* @param outer containing definition context (null if
* at root of tree)
*/
protected DefinitionContext(DefinitionContext outer) {
m_outerContext = outer;
}
/**
* Copy a context for use by an included binding. The duplicated context has
* the same containing context as the original, and shared reference
* structures for formats and templates, but only a static copy of the
* namespace definitions.
*
* @return context copy for included binding
*/
/*package*/ DefinitionContext getIncludeCopy() {
DefinitionContext dupl = new DefinitionContext(m_outerContext);
if (m_mappingMap == null) {
m_mappingMap = new HashMap();
}
dupl.m_mappingMap = m_mappingMap;
if (m_formatContext == null) {
m_formatContext =
new ClassHierarchyContext(getContainingFormatContext());
}
dupl.m_formatContext = m_formatContext;
if (m_templateContext == null) {
m_templateContext =
new ClassHierarchyContext(getContainingTemplateContext());
}
dupl.m_templateContext = m_templateContext;
return dupl;
}
/**
* Inject namespaces from this context into another context. This is
* intended for includes, where the included binding inherits the
* namespace declarations of the containing binding.
*
* @param to
*/
/*package*/ void injectNamespaces(DefinitionContext to) {
to.m_attributeDefault = m_attributeDefault;
to.m_elementDefault = m_elementDefault;
if (m_namespaces != null) {
to.m_namespaces = new ArrayList(m_namespaces);
to.m_prefixMap = new HashMap(m_prefixMap);
to.m_uriMap = new HashMap(m_uriMap);
}
}
/**
* Get containing context.
*
* @return containing context information (null if at root of
* tree)
*/
public DefinitionContext getContaining() {
return m_outerContext;
}
/**
* Get containing format context.
*
* @return innermost containing context for format definitions
* (null none defined)
*/
private ClassHierarchyContext getContainingFormatContext() {
if (m_outerContext == null) {
return null;
} else {
return m_outerContext.getFormatContext();
}
}
/**
* Get current format context.
*
* @return innermost context for format definitions (null none
* defined)
*/
private ClassHierarchyContext getFormatContext() {
if (m_formatContext == null) {
return getContainingFormatContext();
} else {
return m_formatContext;
}
}
/**
* Get containing template context.
*
* @return innermost containing context for template definitions
* (null none defined)
*/
private ClassHierarchyContext getContainingTemplateContext() {
if (m_outerContext == null) {
return null;
} else {
return m_outerContext.getTemplateContext();
}
}
/**
* Get current template context.
*
* @return innermost context for template definitions (null none
* defined)
*/
private ClassHierarchyContext getTemplateContext() {
if (m_templateContext == null) {
return getContainingTemplateContext();
} else {
return m_templateContext;
}
}
/**
* Add namespace to set defined at this level.
*
* @param def namespace definition element to be added
* @return problem information, or null if no problem
*/
/* public ValidationProblem addNamespace(NamespaceElement def) {
// initialize structures if first namespace definition
if (m_namespaces == null) {
m_namespaces = new ArrayList();
m_prefixMap = new HashMap();
m_uriMap = new HashMap();
}
// check for conflict as default for attributes
if (def.isAttributeDefault()) {
if (m_attributeDefault == null) {
m_attributeDefault = def;
} else {
return new ValidationProblem
("Conflicting attribute namespaces", def);
}
}
// check for conflict as default for elements
if (def.isElementDefault()) {
if (m_elementDefault == null) {
m_elementDefault = def;
} else {
return new ValidationProblem
("Conflicting element namespaces", def);
}
}
// check for conflict on prefix
String prefix = def.getPrefix();
if (m_prefixMap.get(prefix) != null) {
return new ValidationProblem("Namespace prefix conflict", def);
}
// check for duplicate definition of same URI
String uri = def.getUri();
Object prior = m_uriMap.get(uri);
if (prior != null && ((NamespaceElement)prior).getPrefix() != null) {
// TODO: is this needed? multiple prefixes should be allowed
return null;
}
// add only if successful in all tests
m_namespaces.add(def);
m_prefixMap.put(prefix, def);
m_uriMap.put(uri, def);
return null;
} */
/**
* Get the default namespace applied to element definitions. If there's no
* default namespace at this level of definitions this moves up the nested
* definitions contexts until one is found.
*
* @return default namespace (null if none)
*/
public NamespaceElement getElementDefaultNamespace() {
DefinitionContext defctx = this;
while (defctx.m_elementDefault == null) {
defctx = defctx.getContaining();
if (defctx == null) {
return null;
}
}
return defctx.m_elementDefault;
}
/**
* Get namespace for prefix.
*
* @param prefix
* @return namespace definition in this context, null if none
*/
public NamespaceElement getNamespaceForPrefix(String prefix) {
if (m_prefixMap == null) {
return null;
} else {
return (NamespaceElement)m_prefixMap.get(prefix);
}
}
/**
* Check for namespace using the same prefix. This also intializes the
* namespace structures for this context the first time the method is
* called.
*
* @param def
* @return namespace definition using same prefix, null if none
*/
private NamespaceElement checkDuplicatePrefix(NamespaceElement def) {
// create structures if not already done
if (m_namespaces == null) {
m_namespaces = new ArrayList();
m_prefixMap = new HashMap();
m_uriMap = new HashMap();
}
// check for conflict (or duplicate) on prefix
String prefix = def.getPrefix();
return (NamespaceElement)m_prefixMap.get(prefix);
}
/**
* Add namespace to internal tables.
*
* @param def
* @param report report default conflicts as error flag
* @return problem information, or null if no problem
*/
private ValidationProblem internalAddNamespace(NamespaceElement def,
boolean report) {
// check for conflict as default for attributes
if (def.isAttributeDefault()) {
if (m_attributeDefault == null) {
m_attributeDefault = def;
} else if (report) {
return new ValidationProblem
("Conflicting attribute namespaces", def);
}
}
// check for conflict as default for elements
if (def.isElementDefault()) {
if (m_elementDefault == null) {
m_elementDefault = def;
} else if (report) {
return new ValidationProblem
("Conflicting element namespaces", def);
}
}
// add namespace to tables
String uri = def.getUri();
String prefix = def.getPrefix();
m_namespaces.add(def);
m_prefixMap.put(prefix, def);
m_uriMap.put(uri, def);
return null;
}
/**
* Add namespace to set defined at this level.
*
* @param def namespace definition element to be added (duplicates ignored)
* @return problem information, or null if no problem
*/
public ValidationProblem addNamespace(NamespaceElement def) {
String uri = def.getUri();
NamespaceElement dup = checkDuplicatePrefix(def);
if (dup == null || uri.equals(dup.getUri())) {
// no conflicts, add it
return internalAddNamespace(def, true);
} else {
String prefix = def.getPrefix();
if (prefix == null) {
return new ValidationProblem
("Default namespace conflict", def);
} else {
return new ValidationProblem
("Namespace prefix conflict for prefix '" + prefix +
'\'', def);
}
}
}
/**
* Add namespace declaration to set defined at this level.
*
* @param def namespace definition to be added (duplicates ignored)
* @param ref binding element referencing the namespace
* @return problem information, or null if no problem
*/
public ValidationProblem addImpliedNamespace(NamespaceElement def,
ElementBase ref) {
String uri = def.getUri();
NamespaceElement dup = checkDuplicatePrefix(def);
DefinitionContext ctx = this;
String prefix = def.getPrefix();
while (dup == null && (ctx = ctx.getContaining()) != null) {
dup = getNamespaceForPrefix(prefix);
}
if (dup == null) {
// check for no definition of same URI with prefix
NamespaceElement prior = (NamespaceElement)m_uriMap.get(uri);
if (prior == null || prior.getPrefix() == null) {
// no conflicts, add it (but only use defaults if no others set)
return internalAddNamespace(def, false);
}
} else if (!uri.equals(dup.getUri())) {
if (prefix == null) {
return new ValidationProblem
("Default namespace conflict on mapping reference", ref);
} else {
return new ValidationProblem
("Namespace conflict on mapping reference, for prefix '" + prefix +
'\'', ref);
}
}
return null;
}
/**
* Get namespace definition for element name.
* TODO: handle multiple prefixes for namespace, proper screening
*
* @param name attribute group defining name
* @param vctx validation context in use
* @return namespace definition, or null if none that matches
*/
public NamespaceElement getElementNamespace(NameAttributes name,
ValidationContext vctx) {
String uri = name.getUri();
String prefix = name.getPrefix();
NamespaceElement ns = null;
if (uri != null) {
if (m_uriMap != null) {
ns = (NamespaceElement)m_uriMap.get(uri);
if (ns != null) {
if (prefix == null ) {
prefix = ns.getPrefix();
} else if (!prefix.equals(ns.getPrefix())) {
ns = null;
}
}
}
} else if (prefix != null) {
if (m_prefixMap != null) {
ns = (NamespaceElement)m_prefixMap.get(prefix);
}
} else {
ns = m_elementDefault;
}
if (ns == null && m_outerContext != null) {
ns = m_outerContext.getElementNamespace(name, vctx);
if (ns != null && m_prefixMap != null) {
NamespaceElement cns =
(NamespaceElement)m_prefixMap.get(ns.getPrefix());
if (cns != null && ns != cns &&
!(Utility.safeEquals(ns.getUri(), cns.getUri()) &&
Utility.safeEquals(ns.getPrefix(), cns.getPrefix()))) {
StringBuffer buff = new StringBuffer();
if (uri == null) {
buff.append("Conflict between namespace definitions for '");
buff.append(cns.getUri());
if (ns.getUri() == null) {
buff.append("' and no-namespace usage");
} else {
buff.append("' and '");
buff.append(ns.getUri());
buff.append('\'');
}
} else if ("".equals(uri)){
buff.append("Unable to use non-namespaced elements because namespace '");
buff.append(cns.getUri());
buff.append("' is the default");
} else {
buff.append("Unable to use namespace URI '");
buff.append(uri);
buff.append("' due to prefix conflict with namespace '");
buff.append(cns.getUri());
buff.append('\'');
}
vctx.addError(buff.toString());
}
}
}
return ns;
}
/**
* Get namespace definition for attribute name.
* TODO: handle multiple prefixes for namespace, proper screening
*
* @param name attribute group defining name
* @return namespace definition, or null if none that matches
*/
public NamespaceElement getAttributeNamespace(NameAttributes name) {
String uri = name.getUri();
String prefix = name.getPrefix();
NamespaceElement ns = null;
if (uri != null) {
if (m_uriMap != null) {
ns = (NamespaceElement)m_uriMap.get(uri);
if (ns != null && prefix != null) {
if (!prefix.equals(ns.getPrefix())) {
ns = null;
}
}
}
} else if (prefix != null) {
if (m_prefixMap != null) {
ns = (NamespaceElement)m_prefixMap.get(prefix);
}
} else {
ns = m_attributeDefault;
}
if (ns == null && m_outerContext != null) {
ns = m_outerContext.getAttributeNamespace(name);
}
return ns;
}
/**
* Add format to set defined at this level.
*
* @param def format definition element to be added
* @param vctx validation context in use
*/
public void addFormat(FormatElement def, ValidationContext vctx) {
if (m_formatContext == null) {
m_formatContext =
new ClassHierarchyContext(getContainingFormatContext());
}
if (def.isDefaultFormat()) {
IClass clas = def.getType();
m_formatContext.addTypedComponent(clas, def, vctx);
}
String label = def.getLabel();
if (label != null) {
m_formatContext.addNamedComponent(label, def, vctx);
}
}
/**
* Get specific format definition for type. Finds with an exact match
* on the class name, checking the containing definitions if a format
* is not found at this level.
*
* @param type fully qualified class name to be converted
* @return conversion definition for class, or null if not
* found
*/
public FormatElement getSpecificFormat(String type) {
ClassHierarchyContext ctx = getFormatContext();
if (ctx == null) {
return null;
} else {
return (FormatElement)ctx.getSpecificComponent(type);
}
}
/**
* Get named format definition. Finds the format with the supplied
* name, checking the containing definitions if the format is not found
* at this level.
*
* @param name conversion name to be found
* @return conversion definition with specified name, or null
* if no conversion with that name
*/
public FormatElement getNamedFormat(String name) {
ClassHierarchyContext ctx = getFormatContext();
if (ctx == null) {
return null;
} else {
return (FormatElement)ctx.getNamedComponent(name);
}
}
/**
* Get best format definition for class. Finds the format based on the
* inheritance hierarchy for the supplied class. If a specific format for
* the actual class is not found (either in this or a containing level) this
* returns the most specific superclass format.
*
* @param clas information for target conversion class
* @return conversion definition for class, or null if no
* compatible conversion defined
*/
public FormatElement getBestFormat(IClass clas) {
ClassHierarchyContext ctx = getFormatContext();
if (ctx == null) {
return null;
} else {
return (FormatElement)ctx.getMostSpecificComponent(clas);
}
}
/**
* Add mapped name to set defined at this level.
*
* @param name mapped name
* @param def mapping definition
* @param vctx validation context
*/
public void addMappedName(NameAttributes name, MappingElementBase def,
ValidationContext vctx) {
if (m_mappingMap == null) {
m_mappingMap = new HashMap();
}
String fullname = name.getName();
NamespaceElement namespace = getElementNamespace(name, vctx);
if (namespace != null && namespace.getUri() != null) {
fullname = '{' + namespace.getUri() + '}' + fullname;
}
if (m_mappingMap.containsKey(fullname)) {
if (vctx.isInBinding()) {
vctx.addError
("Duplicate mapping name not allowed for unmarshalling");
}
} else {
m_mappingMap.put(fullname, def);
}
}
/**
* Add template or mapping to set defined at this level.
*
* @param def template definition element to be added
* @param vctx validation context in use
*/
public void addTemplate(MappingElementBase def, ValidationContext vctx) {
if (m_templateContext == null) {
m_templateContext =
new ClassHierarchyContext(getContainingTemplateContext());
}
if (def.isDefaultTemplate()) {
IClass clas = def.getHandledClass();
if (vctx.isInBinding() ||
m_templateContext.getSpecificComponent(clas.getName()) == null) {
m_templateContext.addTypedComponent(clas, def, vctx);
}
}
if (def.getTypeName() != null) {
m_templateContext.addNamedComponent(def.getTypeName(),
def, vctx);
}
}
/**
* Get specific template definition for type. Finds with an exact match
* on the class name, checking the containing definitions if a template
* is not found at this level.
*
* @param type fully qualified class name to be converted
* @return template definition for type, or null if not
* found
*/
public TemplateElementBase getSpecificTemplate(String type) {
ClassHierarchyContext ctx = getTemplateContext();
if (ctx == null) {
return null;
} else {
return (TemplateElementBase)ctx.getSpecificComponent(type);
}
}
/**
* Get named template definition. Finds the template with the supplied
* name, checking the containing definitions if the template is not found
* at this level.
* TODO: Make this specific to TemplateElement in 2.0
*
* @param name conversion name to be found
* @return template definition for class, or null if no
* template with that name
*/
public TemplateElementBase getNamedTemplate(String name) {
ClassHierarchyContext ctx = getTemplateContext();
if (ctx == null) {
return null;
} else {
return (TemplateElementBase)ctx.getNamedComponent(name);
}
}
/**
* Checks if a class is compatible with one or more templates. This checks
* based on the inheritance hierarchy for the supplied class, looks for the
* class or interface itself as well as any subclasses or implementations.
*
* @param clas information for target class
* @return true if compatible type, false if not
*/
public boolean isCompatibleTemplateType(IClass clas) {
ClassHierarchyContext chctx = getTemplateContext();
if (chctx == null) {
return false;
} else {
return chctx.isCompatibleType(clas);
}
}
/**
* Add named structure to set defined in this context. For named structures
* only the definition context associated with the binding element should be
* used. This is a kludge, but will go away in 2.0.
*
* @param def structure definition
* @return problem information, or null if no problem
*/
public ValidationProblem addNamedStructure(ContainerElementBase def) {
// create structure if not already done
if (m_namedStructureMap == null) {
m_namedStructureMap = new HashMap();
}
// check for conflict on label before adding to definitions
String label = def.getLabel();
if (m_namedStructureMap.get(label) == null) {
m_namedStructureMap.put(label, def);
return null;
} else {
return new ValidationProblem("Duplicate label \"" + label + '"',
def);
}
}
/**
* Get labeled structure definition within this context. For named
* structures only the definition context associated with the binding
* element should be used. This is a kludge, but will go away in 2.0.
*
* @param label structure definition label
* @return structure definition with specified label, or null
* if not defined
*/
public ContainerElementBase getNamedStructure(String label) {
if (m_namedStructureMap == null) {
return null;
} else {
return (ContainerElementBase)m_namedStructureMap.get(label);
}
}
/**
* Get the namespaces defined in this context
*
* @return namespace definitions (may be null if none)
*/
public ArrayList getNamespaces() {
return m_namespaces;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/SequenceVisitor.java 0000644 0001750 0001750 00000007450 10767276124 026376 0 ustar twerner twerner /*
Copyright (c) 2005-2008, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
/**
* Visitor for child tree of structure with an element definition. This
* verifies that text and CDATA components are only used in ways consistent
* with parsing (i.e., each use must be preceded by a required element).
*/
class SequenceVisitor extends ModelVisitor
{
private final StructureElementBase m_baseStructure;
private final ValidationContext m_validationContext;
private boolean m_isTextAllowed;
/**
* Constructor.
*
* @param base root of subtree being visited (null if not
* a structure)
* @param vctx validation context used for reporting errors
*/
public SequenceVisitor(StructureElementBase base,
ValidationContext vctx) {
m_baseStructure = base;
m_validationContext = vctx;
m_isTextAllowed = true;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ModelVisitor#visit(org.jibx.binding.model.StructureElementBase)
*/
public boolean visit(StructureElementBase node) {
if (node != m_baseStructure && node.hasName()) {
m_isTextAllowed = !node.isOptional();
return false;
} else {
return true;
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ModelVisitor#visit(org.jibx.binding.model.ValueElement)
*/
public boolean visit(ValueElement node) {
switch (node.getStyle()) {
case ValueElement.CDATA_STYLE:
case ValueElement.TEXT_STYLE:
if (m_isTextAllowed) {
m_isTextAllowed = false;
} else {
m_validationContext.addError
("Text value must be preceded by required element",
node);
}
break;
case NestingAttributes.ELEMENT_STYLE:
m_isTextAllowed = !node.isOptional();
break;
case NestingAttributes.ATTRIBUTE_STYLE:
break;
}
return false;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ModelVisitor#exit(org.jibx.binding.model.StructureElementBase)
*/
public void exit(StructureElementBase node) {
if (node.hasName()) {
m_isTextAllowed = !node.isOptional();
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/ElementBase.java 0000644 0001750 0001750 00000016074 11062041122 025405 0 ustar twerner twerner /*
Copyright (c) 2004-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import org.jibx.runtime.ITrackSource;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.util.StringArray;
/**
* Base class for all element structures in binding definition model. This just
* provides the linkages for the binding definition tree structure and related
* validation hooks.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public abstract class ElementBase
{
//
// Element type definitions.
public static final int BINDING_ELEMENT = 0;
public static final int COLLECTION_ELEMENT = 1;
public static final int FORMAT_ELEMENT = 2;
public static final int MAPPING_ELEMENT = 3;
public static final int NAMESPACE_ELEMENT = 4;
public static final int STRUCTURE_ELEMENT = 5;
public static final int TEMPLATE_ELEMENT = 6;
public static final int VALUE_ELEMENT = 7;
// special elements eliminated during splitting
public static final int INCLUDE_ELEMENT = 8;
public static final int SPLIT_ELEMENT = 9;
public static final int INPUT_ELEMENT = 10;
public static final int OUTPUT_ELEMENT = 11;
public static final String[] ELEMENT_NAMES =
{
"binding", "collection", "format", "mapping", "namespace", "structure",
"template", "value", "include", "split", "input", "output"
};
//
// Instance data.
/** Element type. */
private final int m_type;
/** Comment associated with element. */
private String m_comment;
/**
* Constructor.
*
* @param type element type code
*/
protected ElementBase(int type) {
m_type = type;
}
/**
* Get element type.
*
* @return type code for this element
*/
public final int type() {
return m_type;
}
/**
* Get element name.
*
* @return type code for this element
*/
public final String name() {
return ELEMENT_NAMES[m_type];
}
/**
* Get element comment.
*
* @return comment for this element
*/
public final String getComment() {
return m_comment;
}
/**
* Set element comment.
*
* @param text comment for this element
*/
public final void setComment(String text) {
m_comment = text;
}
/**
* Validate attributes of element. This is designed to be called during
* unmarshalling as part of the pre-set method processing when a subclass
* instance is being created.
*
* @param ictx unmarshalling context
* @param attrs attributes array
*/
protected void validateAttributes(IUnmarshallingContext ictx,
StringArray attrs) {
// setup for attribute access
int count = ictx.getStackDepth();
BindingElement.UnmarshalWrapper wrapper =
(BindingElement.UnmarshalWrapper)ictx.getStackObject(count-1);
ValidationContext vctx = wrapper.getValidation();
UnmarshallingContext uctx = (UnmarshallingContext)ictx;
// loop through all attributes of current element
for (int i = 0; i < uctx.getAttributeCount(); i++) {
// check if nonamespace attribute is in the allowed set
String name = uctx.getAttributeName(i);
if (uctx.getAttributeNamespace(i).length() == 0) {
if (attrs.indexOf(name) < 0) {
vctx.addWarning("Undefined attribute " + name, this);
}
}
}
}
/**
* Prevalidate element information. The prevalidation step is used to
* check isolated aspects of an element, such as the settings for enumerated
* values on the element and attributes. This empty base class
* implementation should be overridden by each subclass that requires
* prevalidation handling.
*
* @param vctx validation context
*/
public void prevalidate(ValidationContext vctx) {}
/**
* Validate element information. The validation step is used for checking
* the interactions between elements, such as name references to other
* elements. The {@link #prevalidate} method will always be called for every
* element in the binding definition before this method is called for any
* element. This empty base class implementation should be overridden by
* each subclass that requires validation handling.
*
* @param vctx validation context
*/
public void validate(ValidationContext vctx) {}
/**
* Simple text representation of binding definition element. This uses the
* element name, along with position information if present.
*
* @return text representation
*/
public String toString() {
StringBuffer buff = new StringBuffer();
buff.append('<');
buff.append(name());
buff.append('>');
buff.append(" element");
if (this instanceof ITrackSource) {
ITrackSource track = (ITrackSource)this;
int line = track.jibx_getLineNumber();
if (line >= 0) {
buff.append(" (line ");
buff.append(line);
buff.append(", column ");
buff.append(track.jibx_getColumnNumber());
String dname = track.jibx_getDocumentName();
if (dname == null) {
buff.append(')');
} else {
buff.append(" in '");
buff.append(dname);
buff.append("')");
}
}
}
return buff.toString();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/StringAttributes.java 0000644 0001750 0001750 00000057011 11262224142 026541 0 ustar twerner twerner /*
Copyright (c) 2004-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.util.IClass;
import org.jibx.util.IClassItem;
import org.jibx.util.StringArray;
/**
* Model component for string attribute group in binding definition.
*
* @author Dennis M. Sosnoski
*/
public class StringAttributes extends AttributeBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "default", "deserializer",
"enum-value-method", "serializer", "whitespace" });
// TODO: add "format" for 2.0
//
// Constants and such related to code generation.
// signature variants allowed for serializer
private static final String[] SERIALIZER_SIGNATURE_VARIANTS =
{
"Lorg/jibx/runtime/IMarshallingContext;",
"Ljava/lang/Object;",
""
};
// signatures allowed for deserializer
private static final String[] DESERIALIZER_SIGNATURES =
{
"(Ljava/lang/String;Lorg/jibx/runtime/IUnmarshallingContext;)",
"(Ljava/lang/String;Ljava/lang/Object;)",
"(Ljava/lang/String;)"
};
// signatures allowed for enum-value-method
private static final String ENUM_VALUE_METHOD_SIGNATURE =
"()Ljava/lang/String;";
// signature required for constructor from string
private static final String STRING_CONSTRUCTOR_SIGNATURE =
"(Ljava/lang/String;)";
// classes of arguments to constructor or deserializer
private static final Class[] STRING_CONSTRUCTOR_ARGUMENT_CLASSES =
{
java.lang.String.class
};
//
// Enumeration for whitespace processing.
public static final int PRESERVE_WHITESPACE = 0;
public static final int REPLACE_WHITESPACE = 1;
public static final int COLLAPSE_WHITESPACE = 2;
public static final int TRIM_WHITESPACE = 3;
public static final EnumSet s_whitespaceEnum =
new EnumSet(PRESERVE_WHITESPACE,
new String[] { "preserve", "replace", "collapse", "trim" });
//
// Instance data.
/** Referenced format name. */
private String m_formatName;
/** Format qualified name. */
private QName m_formatQName;
/** Default value text. */
private String m_defaultText;
/** Serializer fully qualified class and method name. */
private String m_serializerName;
/** Whitespace handling name. */
private String m_whitespaceName;
/** Actual selected whitespace handling. */
private int m_whitespaceIndex;
/** Deserializer fully qualified class and method name. */
private String m_deserializerName;
/** Enum value method name. */
private String m_enumValueName;
/** Base format for conversions. */
private FormatElement m_baseFormat;
/** Value type class. */
private IClass m_typeClass;
/** Default value object. */
private Object m_default;
/** Serializer method (or toString equivalent) information. */
private IClassItem m_serializerItem;
/** Deserializer method (or constructor from string) information. */
private IClassItem m_deserializerItem;
/** Method used to get text representation of an enum. */
private IClassItem m_enumValueItem;
/**
* Default constructor.
*/
public StringAttributes() {}
/**
* Set value type. This needs to be set by the owning element prior to
* validation. Even though the type is an important part of the string
* information, it's treated as a separate item of information because it
* needs to be used as part of the property attributes.
*
* @param type value type
*/
public void setType(IClass type) {
m_typeClass = type;
}
/**
* Get value type.
*
* @return value type
*/
public IClass getType() {
return m_typeClass;
}
/**
* Get base format name.
*
* @return referenced base format
*/
public String getFormatName() {
return m_formatName;
}
/**
* Set base format name.
*
* @param name referenced base format
*/
public void setFormatName(String name) {
m_formatName = name;
m_formatQName = (name == null) ? null : new QName(name);
}
/**
* Get format qualified name.
*
* @return format qualified name (null if none)
*/
public QName getFormatQName() {
return m_formatQName;
}
/**
* Set format qualified name. This method changes the label value to match
* the qualified name.
*
* @param qname format qualified name (null if none)
*/
public void setFormatQName(QName qname) {
m_formatQName = qname;
m_formatName = (qname == null) ? null : qname.toString();
}
/**
* Get default value text.
*
* @return default value text
*/
public String getDefaultText() {
return m_defaultText;
}
/**
* Get default value. This method is only usable after a
* call to {@link #validate(ValidationContext)}.
*
* @return default value object
*/
public Object getDefault() {
return m_default;
}
/**
* Set default value text.
*
* @param value default value text
*/
public void setDefaultText(String value) {
m_defaultText = value;
}
/**
* Get serializer name.
*
* @return fully qualified class and method name for serializer (or
* null if none)
*/
public String getSerializerName() {
return m_serializerName;
}
/**
* Get serializer method information. This method is only usable after a
* call to {@link #validate(ValidationContext)}.
*
* @return serializer information (or null if none)
*/
public IClassItem getSerializer() {
return m_serializerItem;
}
/**
* Set serializer method name.
*
* @param name fully qualified class and method name for serializer
*/
public void setSerializerName(String name) {
m_serializerName = name;
}
/**
* Set whitespace handling type name.
*
* @param name whitespace handling type
*/
public void setDefaultName(String name) {
m_whitespaceName = name;
}
/**
* Get whitespace handling type name.
*
* @return whitespace handling type
*/
public String getDefaultName() {
return m_whitespaceName;
}
/**
* Get deserializer name.
*
* @return fully qualified class and method name for deserializer (or
* null if none)
*/
public String getDeserializerName() {
return m_deserializerName;
}
/**
* Get deserializer method information. This method is only usable after a
* call to {@link #validate(ValidationContext)}.
*
* @return deserializer information (or null if none)
*/
public IClassItem getDeserializer() {
return m_deserializerItem;
}
/**
* Set deserializer method name.
*
* @param name fully qualified class and method name for deserializer
*/
public void setDeserializerName(String name) {
m_deserializerName = name;
}
/**
* Get enum value method name.
*
* @return enum value method name (or null if none)
*/
public String getEnumValueName() {
return m_enumValueName;
}
/**
* Get enum value method information. This method is only usable after a
* call to {@link #validate(ValidationContext)}.
*
* @return enum value method information (or null if none)
*/
public IClassItem getEnumValue() {
return m_enumValueItem;
}
/**
* Set enum value method name.
*
* @param name enum value method name (null if none)
*/
public void setEnumValueName(String name) {
m_enumValueName = name;
}
/**
* Get base format information. This method is only usable after a
* call to {@link #validate(ValidationContext)}.
*
* @return base format element (or null if none)
*/
public FormatElement getBaseFormat() {
return m_baseFormat;
}
/**
* JiBX access method to set format label as qualified name.
*
* @param label format label text (null if none)
* @param ictx unmarshalling context
* @throws JiBXException on deserialization error
*/
private void setQualifiedFormat(String label, IUnmarshallingContext ictx)
throws JiBXException {
setFormatQName(QName.deserialize(label, ictx));
}
/**
* JiBX access method to get format label as qualified name.
*
* @param ictx marshalling context
* @return format label text (null if none)
* @throws JiBXException on deserialization error
*/
private String getQualifiedFormat(IMarshallingContext ictx)
throws JiBXException {
return QName.serialize(getFormatQName(), ictx);
}
/* (non-Javadoc)
* @see org.jibx.binding.model.AttributeBase#prevalidate(org.jibx.binding.model.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check the specified whitespace handling
if (m_whitespaceName != null) {
m_whitespaceIndex = s_whitespaceEnum.getValue(m_whitespaceName);
if (m_whitespaceIndex < 0) {
vctx.addError("Value \"" + m_whitespaceName +
"\" is not a valid choice for whitespace handling");
}
}
// make sure the type has been configured
if (m_typeClass == null) {
vctx.addFatal("Missing type information for conversion to string");
} else if (vctx.isLookupSupported()) {
// get the base format (if any)
DefinitionContext dctx = vctx.getDefinitions();
if (m_formatName == null) {
m_baseFormat = dctx.getBestFormat(m_typeClass);
} else {
m_baseFormat = dctx.getNamedFormat(m_formatName);
if (m_baseFormat == null) {
String name = m_formatName;
if (name.startsWith("{}")) {
name = name.substring(2);
}
vctx.addError("Unknown format " + name);
}
}
// check for a Java 5 enumeration
boolean isenum = false;
IClass sclas = m_typeClass;
while ((sclas = sclas.getSuperClass()) != null) {
if (sclas.getName().equals("java.lang.Enum")) {
isenum = true;
break;
}
}
// find the enum value method, if specified
if (m_enumValueName != null) {
if (isenum) {
if (m_serializerName == null &&
m_deserializerName == null) {
m_enumValueItem = m_typeClass.getMethod(m_enumValueName,
ENUM_VALUE_METHOD_SIGNATURE);
if (m_enumValueItem == null) {
vctx.addError("Nonstatic 'enum-value-method' " +
m_enumValueName + " not found in class " +
m_typeClass.getName());
}
} else {
vctx.addError("'enum-value-method' cannot be used with 'serializer' or 'deserializer'");
}
} else {
vctx.addError("'enum-value-method' may only be used with Java 5 enum classes");
}
}
// check specified serializer and deserializer
String tname = m_typeClass.getName();
if (vctx.isOutBinding()) {
if (m_serializerName == null) {
if (m_enumValueItem == null) {
// try to find an inherited serializer
FormatElement ances = m_baseFormat;
while (ances != null) {
m_serializerItem = ances.getSerializer();
if (m_serializerItem == null) {
ances = ances.getBaseFormat();
} else {
break;
}
}
if (m_serializerItem == null) {
IClassItem item = m_typeClass.getMethod("toString",
"()Ljava/lang/String;");
if (item == null) {
vctx.addError("toString method not found");
}
}
}
} else {
// build all possible signature variations
String[] tsigs = ClassUtils.
getSignatureVariants(tname, vctx);
int vcnt = SERIALIZER_SIGNATURE_VARIANTS.length;
String[] msigs = new String[tsigs.length * vcnt];
for (int i = 0; i < tsigs.length; i++) {
for (int j = 0; j < vcnt; j++) {
msigs[i*vcnt + j] = "(" + tsigs[i] +
SERIALIZER_SIGNATURE_VARIANTS[j] +
")Ljava/lang/String;";
}
}
// find a matching static method
m_serializerItem = ClassUtils.
findStaticMethod(m_serializerName, msigs, vctx);
if (m_serializerItem == null) {
if (m_serializerName.indexOf('.') > 0) {
vctx.addError("Static serializer method " + m_serializerName + " not found");
} else {
vctx.addError("Need class name for static method " + m_serializerName);
}
}
}
}
if (vctx.isInBinding() || m_defaultText != null) {
if (m_deserializerName == null) {
if (isenum) {
if (m_enumValueItem == null) {
m_deserializerItem = m_typeClass.
getMethod("valueOf", "(Ljava/lang/String;)");
}
} else {
// try to find an inherited deserializer
FormatElement ances = m_baseFormat;
while (ances != null) {
m_deserializerItem = ances.getDeserializer();
if (m_deserializerItem == null) {
ances = ances.getBaseFormat();
} else {
break;
}
}
if (m_deserializerItem == null) {
// try to find constructor from string as last resort
m_deserializerItem = m_typeClass.
getInitializerMethod(STRING_CONSTRUCTOR_SIGNATURE);
if (m_deserializerItem == null) {
// error unless predefined formats
if (vctx.getNestingDepth() > 0) {
StringBuffer buff = new StringBuffer();
buff.append("Need deserializer or constructor from string");
if (!vctx.isInBinding()) {
buff.append(" for default value of type ");
buff.append(tname);
} else {
buff.append(" for type ");
buff.append(tname);
}
vctx.addError(buff.toString());
}
}
}
}
} else {
// find a matching static method
m_deserializerItem = ClassUtils.
findStaticMethod(m_deserializerName,
DESERIALIZER_SIGNATURES, vctx);
if (m_deserializerItem == null) {
if (m_deserializerName.indexOf('.') > 0) {
vctx.addError("Static deserializer method " + m_deserializerName + " not found");
} else {
vctx.addError("Need class name for static method " + m_deserializerName);
}
} else {
String result = m_deserializerItem.getTypeName();
if (!ClassUtils.isAssignable(result, tname, vctx)) {
vctx.addError("Static deserializer method " +
m_deserializerName +
" has incompatible result type");
}
}
}
}
// check for default value to be converted
if (m_defaultText != null && m_deserializerItem != null) {
// first load the class to handle conversion
IClass iclas = m_deserializerItem.getOwningClass();
Class clas = iclas.loadClass();
Exception ex = null;
boolean construct = false;
try {
if (clas == null) {
vctx.addError("Unable to load class " +
iclas.getName() +
" for converting default value of type " + tname);
} else if (m_deserializerItem.isInitializer()) {
// invoke constructor to process default value
construct = true;
Constructor cons = clas.getConstructor
(STRING_CONSTRUCTOR_ARGUMENT_CLASSES);
try {
cons.setAccessible(true);
} catch (Exception e) { /* deliberately left empty */ }
Object[] args = new Object[1];
args[0] = m_defaultText;
m_default = cons.newInstance(args);
} else {
// invoke deserializer to convert default value
String mname = m_deserializerItem.getName();
Method deser = clas.getDeclaredMethod(mname,
STRING_CONSTRUCTOR_ARGUMENT_CLASSES);
try {
deser.setAccessible(true);
} catch (Exception e) { /* deliberately left empty */ }
Object[] args = new Object[1];
args[0] = m_defaultText;
m_default = deser.invoke(null, args);
}
} catch (SecurityException e) {
StringBuffer buff = new StringBuffer("Unable to access ");
if (construct) {
buff.append("constructor from string");
} else {
buff.append("deserializer ");
buff.append(m_deserializerName);
}
buff.append(" for converting default value of type ");
buff.append(tname);
vctx.addError(buff.toString());
} catch (NoSuchMethodException e) {
StringBuffer buff = new StringBuffer("Unable to find ");
if (construct) {
buff.append("constructor from string");
} else {
buff.append("deserializer ");
buff.append(m_deserializerName);
}
buff.append(" for converting default value of type ");
buff.append(tname);
vctx.addError(buff.toString());
} catch (IllegalArgumentException e) {
ex = e;
} catch (InstantiationException e) {
ex = e;
} catch (IllegalAccessException e) {
ex = e;
} catch (InvocationTargetException e) {
ex = e;
} finally {
if (ex != null) {
StringBuffer buff = new StringBuffer("Error calling ");
if (construct) {
buff.append("constructor from string");
} else {
buff.append("deserializer ");
buff.append(m_deserializerName);
}
buff.append(" for converting default value of type ");
buff.append(tname);
vctx.addError(buff.toString());
}
}
}
}
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/SplitElement.java 0000644 0001750 0001750 00000005773 10210703672 025643 0 ustar twerner twerner /*
Copyright (c) 2004-2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
/**
* Model component for split element of binding definition. This is only
* used for structuring purposes, and is eliminated when the binding definition
* is split into specialized input and output versions.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class SplitElement extends NestingElementBase
{
/** Input side of binding (null if none). */
private InputElement m_inputSide;
/** Output side of binding (null if none). */
private OutputElement m_outputSide;
/**
* Constructor.
*/
public SplitElement() {
super(SPLIT_ELEMENT);
}
/**
* Get input side of binding.
*
* @return input side (null if none)
*/
public InputElement getInputSide() {
return m_inputSide;
}
/**
* Set input side of binding.
*
* @param input element containing input binding definition
* (null if none)
*/
public void setInputSide(InputElement input) {
m_inputSide = input;
}
/**
* Get output side of binding.
*
* @return output side (null if none)
*/
public OutputElement getOutputSide() {
return m_outputSide;
}
/**
* Set output side of binding.
*
* @param output element containing output binding definition
* (null if none)
*/
public void setOutputSide(OutputElement output) {
m_outputSide = output;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/MappingElementBase.java 0000644 0001750 0001750 00000027227 11524073040 026732 0 ustar twerner twerner /*
Copyright (c) 2004-2011, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.util.IClass;
import org.jibx.util.StringArray;
/**
* Model component for mapping element of binding definition. Subclasses
* are used for mappings in normal or precompiled bindings.
*
* @author Dennis M. Sosnoski
*/
public abstract class MappingElementBase extends TemplateElementBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes = new StringArray(new String[]
{ "abstract", "class", "extends", "type-name" },
new StringArray(NameAttributes.s_allowedAttributes,
ContainerElementBase.s_allowedAttributes));
/** Abstract mapping flag. */
private boolean m_isAbstract;
/** Name attributes information for nesting. */
private NameAttributes m_nameAttrs;
/** Name of mapped class extended by this mapping. */
private String m_extendsName;
/** Type qualified name (defaults to fully-qualified class name in
no-namespace namespace). */
private QName m_typeQName;
/**
* Constructor.
*
* @param type element type code
*/
public MappingElementBase(int type) {
super(type);
m_nameAttrs = new NameAttributes();
}
/**
* Check for abstract mapping.
*
* @return true if abstract, false if not
*/
public boolean isAbstract() {
return m_isAbstract;
}
/**
* Set abstract mapping.
*
* @param abs true if abstract, false if not
*/
public void setAbstract(boolean abs) {
m_isAbstract = abs;
}
/**
* Get type name.
*
* @return type name
*/
public String getTypeName() {
return (m_typeQName == null) ? null : m_typeQName.toString();
}
/**
* Set type name.
*
* @param name type name
*/
public void setTypeName(String name) {
m_typeQName = new QName(name);
}
/**
* Get type qualified name.
*
* @return type qualified name
*/
public QName getTypeQName() {
return m_typeQName;
}
/**
* Set type qualified name.
*
* @param qname type qualified name
*/
public void setTypeQName(QName qname) {
m_typeQName = qname;
}
/**
* Check if this is a default template.
*
* @return true if default, false if not
*/
public boolean isDefaultTemplate() {
return m_typeQName == null;
}
/**
* Get name attributes. This is provided for use with the name attributes as
* a hash key.
*
* @return name attributes structure
*/
public NameAttributes getNameAttributes() {
return m_nameAttrs;
}
/**
* Get name.
*
* @return name text
*/
public String getName() {
return m_nameAttrs.getName();
}
/**
* Set name.
*
* @param name text for name
*/
public void setName(String name) {
m_nameAttrs.setName(name);
}
/**
* Get specified namespace URI.
*
* @return namespace URI (null if not set)
*/
public String getUri() {
return m_nameAttrs.getUri();
}
/**
* Set namespace URI.
*
* @param uri namespace URI (null if not set)
*/
public void setUri(String uri) {
m_nameAttrs.setUri(uri);
}
/**
* Get specified namespace prefix.
*
* @return namespace prefix (null if not set)
*/
public String getPrefix() {
return m_nameAttrs.getPrefix();
}
/**
* Set namespace prefix.
*
* @param prefix namespace prefix (null if not set)
*/
public void setPrefix(String prefix) {
m_nameAttrs.setPrefix(prefix);
}
/**
* Get effective namespace information. This call is only meaningful after
* validation.
*
* @return effective namespace information
*/
public NamespaceElement getNamespace() {
return m_nameAttrs.getNamespace();
}
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
* @exception JiBXException on unmarshalling error
*/
private void preSet(IUnmarshallingContext uctx) throws JiBXException {
validateAttributes(uctx, s_allowedAttributes);
}
/**
* Set name of mapped class extended by this one.
*
* @param name
*/
public void setExtendsName(String name) {
m_extendsName = name;
}
/**
* Get name of mapped class extended by this one.
*
* @return name
*/
public String getExtendsName() {
return m_extendsName;
}
/**
* JiBX access method to set mapping type name as qualified name.
*
* @param text mapping name text (null if none)
* @param ictx unmarshalling context
* @throws JiBXException on deserialization error
*/
private void setQualifiedTypeName(String text, IUnmarshallingContext ictx) throws JiBXException {
m_typeQName = QName.deserialize(text, ictx);
}
/**
* JiBX access method to get mapping type name as qualified name.
*
* @param ictx marshalling context
* @return mapping type name text (null if none)
* @throws JiBXException on deserialization error
*/
private String getQualifiedTypeName(IMarshallingContext ictx) throws JiBXException {
return QName.serialize(m_typeQName, ictx);
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#prevalidate(org.jibx.binding.model.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
m_nameAttrs.prevalidate(vctx);
if (m_isAbstract) {
if (m_typeQName != null && m_nameAttrs.getName() != null) {
vctx.addError("Type name cannot be used with an element name");
}
if (isNillable()) {
vctx.addError
("nillable='true' cannot be used on an abstract mapping");
}
} else {
if (m_nameAttrs.getName() == null) {
if ((vctx.isInBinding() && getUnmarshallerName() == null) ||
(vctx.isOutBinding() && getMarshallerName() == null)) {
vctx.addError
("Non-abstract mapping must define an element name");
}
if (isNillable()) {
vctx.addError
("nillable='true' cannot be used without an element name");
}
}
if (m_typeQName != null) {
vctx.addError
("Type name can only be used with an abstract mapping");
}
}
super.prevalidate(vctx);
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#validate(org.jibx.binding.model.ValidationContext)
*/
public void validate(ValidationContext vctx) {
if (isAbstract()) {
m_nameAttrs.validate(vctx);
}
// check use of text values in children of structure with name
SequenceVisitor visitor = new SequenceVisitor(null, vctx);
TreeContext tctx = vctx.getChildContext();
tctx.tourTree(this, visitor);
// check for class that probably should extend another mapped class
if (m_extendsName == null) {
if (vctx.isLookupSupported() && !m_isAbstract) {
// first check ancestor classes for ones with specific mappings
DefinitionContext defc = vctx.getCurrentDefinitions();
IClass sclass = getHandledClass().getSuperClass();
if (sclass != null) {
TemplateElementBase stmpl =
defc.getSpecificTemplate(sclass.getName());
if (stmpl != null) {
if (stmpl instanceof MappingElementBase) {
MappingElementBase smap = (MappingElementBase)stmpl;
if (smap.getExtensionTypes().size() > 0) {
vctx.addWarning("Class " + getClassName() +
" extends " + smap.getClassName() +
" which has a base mapping with extensions, but this mapping does not extend it");
}
}
}
}
// next check interfaces for ones with specific mappings
String[] interfaces = getHandledClass().getInterfaces();
for (int i = 0; i < interfaces.length; i++) {
String iname = interfaces[i];
TemplateElementBase itmpl = defc.getSpecificTemplate(iname);
if (itmpl != null) {
if (itmpl instanceof MappingElementBase) {
MappingElementBase smap = (MappingElementBase)itmpl;
if (smap.getExtensionTypes().size() > 0) {
vctx.addWarning("Class " + getClassName() +
" implements " + iname +
" which has a base mapping with extensions, but this mapping does not extend it");
}
}
break;
}
}
}
} else {
if (m_extendsName.equals(getClassName())) {
vctx.addError("Mapping cannot extend itself");
}
if (m_isAbstract && getExtensionTypes().size() == 0) {
vctx.addWarning("Only concrete mappings should be 'leaf' mappings for extensions; you should either remove 'extends' attribute or add concrete extension mappings for this abstract mapping");
}
}
// run base class validation
super.validate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/StructureAttributes.java 0000644 0001750 0001750 00000016217 11072762652 027312 0 ustar twerner twerner /*
Copyright (c) 2004-2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import org.jibx.util.StringArray;
/**
* Model component for structure attribute group in binding definition.
*
* @author Dennis M. Sosnoski
*/
public class StructureAttributes extends AttributeBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "allow-repeats", "choice", "flexible",
"label", "ordered", "using" });
//
// Instance data.
/** Flexible element handling flag. */
private boolean m_isFlexible;
/** Flag for ordered child content. */
private boolean m_isOrdered;
/** Flag for choice child content. */
private boolean m_isChoice;
/** Flag for repeated child elements to be ignored. */
private boolean m_isAllowRepeats;
/** Name for labeled child content defined elsewhere. */
private String m_usingName;
/** Name for labeled child content potentially referenced elsewhere. */
private String m_labelName;
/**
* Constructor.
*/
public StructureAttributes() {
m_isOrdered = true;
}
/**
* Get flexible flag.
*
* @return flexible flag
*/
public boolean isFlexible() {
return m_isFlexible;
}
/**
* Set flexible flag.
*
* @param flexible
*/
public void setFlexible(boolean flexible) {
m_isFlexible = flexible;
}
/**
* Check if child components are ordered.
*
* @return true if ordered, false if not
*/
public boolean isOrdered() {
return m_isOrdered;
}
/**
* Set child components ordered flag.
*
* @param ordered true if ordered, false if not
*/
public void setOrdered(boolean ordered) {
m_isOrdered = ordered;
}
/**
* Check if child components are a choice.
*
* @return true if choice, false if not
*/
public boolean isChoice() {
return m_isChoice;
}
/**
* Set child components choice flag.
*
* @param choice true if choice, false if not
*/
public void setChoice(boolean choice) {
m_isChoice = choice;
}
/**
* Check if repeated child elements are allowed.
*
* @return true if repeats allowed, false if not
*/
public boolean isAllowRepeats() {
return m_isAllowRepeats;
}
/**
* Set repeated child elements allowed flag.
*
* @param ignore true if repeated child elements to be allowed,
* false if not
*/
public void setAllowRepeats(boolean ignore) {
m_isAllowRepeats = ignore;
}
/**
* Get name for child component list definition.
*
* @return text of name defining child components (null if
* none)
*/
public String getUsingName() {
return m_usingName;
}
/**
* Set name for child component list definition.
*
* @param name text of name defining child components (null if
* none)
*/
public void setUsingName(String name) {
m_usingName = name;
}
/**
* Get label name for child component list.
*
* @return label name text (null if none)
*/
public String getLabelName() {
return m_labelName;
}
/**
* Set label name for child component list.
*
* @param name label text for name (null if none)
*/
public void setLabelName(String name) {
m_labelName = name;
}
/* (non-Javadoc)
* @see org.jibx.binding.model.AttributeBase#prevalidate(org.jibx.binding.model.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
if (m_isOrdered) {
if (m_isChoice) {
vctx.addError
("choice='true' cannot be used with ordered children");
}
if (m_isFlexible) {
vctx.addError
("flexible='true' cannot be used with ordered children");
}
if (m_isAllowRepeats) {
vctx.addError
("allow-repeats='true' cannot be used with ordered children");
}
}
if (m_isChoice && m_isFlexible) {
vctx.addError
("choice='true' and flexible='true' cannot be used together");
}
if (m_isChoice && m_isAllowRepeats) {
vctx.addError
("choice='true' and allow-repeats='true' cannot be used together");
}
super.prevalidate(vctx);
}
/* (non-Javadoc)
* @see org.jibx.binding.model.AttributeBase#validate(org.jibx.binding.model.ValidationContext)
*/
public void validate(ValidationContext vctx) {
if (m_usingName != null) {
DefinitionContext dctx = vctx.getBindingRoot().getDefinitions();
if (dctx.getNamedStructure(m_usingName) == null) {
vctx.addError("Label \"" + m_usingName + "\" is not defined");
} else {
vctx.addWarning("The label/using approach is deprecated and " +
"will not be supported in the future - consider using an " +
"abstract mapping instead");
}
}
if (m_labelName != null) {
vctx.addWarning("The label/using approach is deprecated and " +
"will not be supported in the future - consider using an " +
"abstract mapping instead");
}
super.validate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/MappingElement.java 0000644 0001750 0001750 00000012533 11027507050 026132 0 ustar twerner twerner /*
Copyright (c) 2004-2008, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.util.ArrayList;
/**
* Model component for mapping element of normal binding definition.
*
* @author Dennis M. Sosnoski
*/
public class MappingElement extends MappingElementBase
{
/** Mapping extended by this mapping. */
private MappingElement m_extendsMapping;
/** Constructability verified flag. */
private boolean m_constructVerified;
/**
* Default constructor.
*/
public MappingElement() {
super(MAPPING_ELEMENT);
m_topChildren = new ArrayList();
}
/**
* Get mapping extended by this one.
*
* @return mapping extended by this one
*/
public MappingElement getExtendsMapping() {
return m_extendsMapping;
}
/**
* Verify that instances of the mapped class can be constructed. This
* method may be called during the {@link #validate(ValidationContext)}
* processing of other elements. If this mapping has any extensions, the
* check is ignored.
* TODO: check that at least one of the extensions can be created
*
* @param vctx
*/
public void verifyConstruction(ValidationContext vctx) {
if (!m_constructVerified && getExtensionTypes().size() == 0) {
verifyConstruction(vctx, getHandledClass());
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#validate(org.jibx.binding.model.ValidationContext)
*/
public void validate(ValidationContext vctx) {
// make sure we can construct instances of concrete mapped class
if (!isAbstract()) {
verifyConstruction(vctx, getHandledClass());
m_constructVerified = true;
}
// run base class validation
super.validate(vctx);
}
/**
* Special validation method to link extension mappings to base mappings.
* This is called as a special step following registration, so that the
* normal validation pass can make use of the linkage information.
*
* @param vctx validation context
*/
public void validateExtension(ValidationContext vctx) {
String extend = getExtendsName();
if (extend != null) {
// find the base class mapping
TemplateElementBase base =
vctx.getDefinitions().getSpecificTemplate(extend);
if (base instanceof MappingElement) {
if (base != this) {
// check base class using custom marshaller/unmarshaller
MappingElement mbase = (MappingElement)base;
if (mbase.getMarshaller() != null ||
mbase.getUnmarshaller() != null) {
vctx.addError("Cannot extend a mapping using custom " +
"marshaller/unmarshaller");
}
// add reference to base class
mbase.addExtensionType(this);
m_extendsMapping = mbase;
// check for circular references
MappingElementBase mark = this;
boolean skip = true;
while (mbase != null) {
if (mbase == mark) {
vctx.addError("Circular 'extends' reference chain",
mbase);
break;
} else if (skip) {
skip = false;
} else {
mark = mbase;
skip = true;
}
mbase = mbase.getExtendsMapping();
}
}
} else {
vctx.addFatal("No mapping found for class " + extend);
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/IComponent.java 0000644 0001750 0001750 00000007226 11072762652 025316 0 ustar twerner twerner /*
Copyright (c) 2004-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import org.jibx.util.IClass;
/**
* Child component interface definition. This is the basic interface implemented
* by every binding definition element that actually participates in the nested
* structure of a binding (as opposed to elements such as format
* elements, which are simply convenience shortcuts). It defines the hooks used
* to handle structure validation of a binding definition model.
*
* @author Dennis M. Sosnoski
*/
public interface IComponent
{
/**
* Check if component is an optional item.
*
* @return true if optional, false if required
*/
boolean isOptional();
/**
* Check if component defines one or more attribute values of the
* containing element. This method is only valid after validation.
*
* @return true if one or more attribute values defined for
* containing element, false if not
*/
boolean hasAttribute();
/**
* Check if component defines one or more elements or text values as
* children of the containing element. This method is only valid after
* validation.
*
* @return true if one or more content values defined
* for containing element, false if not
*/
boolean hasContent();
/**
* Check if component has a name.
*
* @return true if component has a name, false if
* not
*/
boolean hasName();
/**
* Get name.
*
* @return name text
*/
String getName();
/**
* Get specified namespace URI.
*
* @return namespace URI (null if not set)
*/
String getUri();
/**
* Get value type information. This call is only meaningful after
* prevalidation.
*
* @return type information
*/
IClass getType();
/**
* Check if this structure implicitly uses the containing object. This call
* is only meaningful after prevalidation.
*
* @return true if using the containing object,
* false if own object
*/
boolean isImplicit();
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/BuiltinFormats.java 0000644 0001750 0001750 00000016150 11362667734 026210 0 ustar twerner twerner /*
* Copyright (c) 2008-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.binding.model;
/**
* Built-in <format> definitions.
*
* @author Dennis M. Sosnoski
*/
public abstract class BuiltinFormats
{
/** Default format definitions. */
public static final FormatElement[] s_builtinFormats = {
buildFormat("byte.default", "byte", true, "org.jibx.runtime.Utility.serializeByte",
"org.jibx.runtime.Utility.parseByte", "0"),
buildFormat("char.default", "char", true, "org.jibx.runtime.Utility.serializeChar",
"org.jibx.runtime.Utility.parseChar", "0"),
buildFormat("double.default", "double", true, "org.jibx.runtime.Utility.serializeDouble",
"org.jibx.runtime.Utility.parseDouble", "0.0"),
buildFormat("float.default", "float", true, "org.jibx.runtime.Utility.serializeFloat",
"org.jibx.runtime.Utility.parseFloat", "0.0"),
buildFormat("int.default", "int", true, "org.jibx.runtime.Utility.serializeInt",
"org.jibx.runtime.Utility.parseInt", "0"),
buildFormat("long.default", "long", true, "org.jibx.runtime.Utility.serializeLong",
"org.jibx.runtime.Utility.parseLong", "0"),
buildFormat("short.default", "short", true, "org.jibx.runtime.Utility.serializeShort",
"org.jibx.runtime.Utility.parseShort", "0"),
buildFormat("boolean.default", "boolean", true, "org.jibx.runtime.Utility.serializeBoolean",
"org.jibx.runtime.Utility.parseBoolean", "false"),
buildFormat("Date.default", "java.util.Date", true, "org.jibx.runtime.Utility.serializeDateTime",
"org.jibx.runtime.Utility.deserializeDateTime", null),
//#!j2me{
buildFormat("SqlDate.default", "java.sql.Date", true, "org.jibx.runtime.Utility.serializeSqlDate",
"org.jibx.runtime.Utility.deserializeSqlDate", null),
buildFormat("SqlTime.default", "java.sql.Time", true, "org.jibx.runtime.Utility.serializeSqlTime",
"org.jibx.runtime.Utility.deserializeSqlTime", null),
buildFormat("SqlTimestamp.default", "java.sql.Timestamp", true, "org.jibx.runtime.Utility.serializeTimestamp",
"org.jibx.runtime.Utility.deserializeTimestamp", null),
buildFormat("LocalDate.default", "org.joda.time.LocalDate", true,
"org.jibx.runtime.JodaConvert.serializeLocalDate",
"org.jibx.runtime.JodaConvert.deserializeLocalDate", null),
buildFormat("DateMidnight.zoned", "org.joda.time.DateMidnight", false,
"org.jibx.runtime.JodaConvert.serializeZonedDateMidnight",
"org.jibx.runtime.JodaConvert.deserializeZonedDateMidnight", null),
buildFormat("DateMidnight.local", "org.joda.time.DateMidnight", true,
"org.jibx.runtime.JodaConvert.serializeUnzonedDateMidnight",
"org.jibx.runtime.JodaConvert.deserializeLocalDateMidnight", null),
buildFormat("DateMidnight.UTC", "org.joda.time.DateMidnight", false,
"org.jibx.runtime.JodaConvert.serializeUTCDateMidnight",
"org.jibx.runtime.JodaConvert.deserializeUTCDateMidnight", null),
buildFormat("LocalTime.local", "org.joda.time.LocalTime", true,
"org.jibx.runtime.JodaConvert.serializeUnzonedLocalTime",
"org.jibx.runtime.JodaConvert.deserializeLocalTime", null),
buildFormat("LocalTime.UTC", "org.joda.time.LocalTime", false,
"org.jibx.runtime.JodaConvert.serializeUTCLocalTime",
"org.jibx.runtime.JodaConvert.deserializeLocalTime", null),
buildFormat("DateTime.zoned", "org.joda.time.DateTime", false,
"org.jibx.runtime.JodaConvert.serializeZonedDateTime",
"org.jibx.runtime.JodaConvert.deserializeZonedDateTime", null),
buildFormat("DateTime.UTC", "org.joda.time.DateTime", false,
"org.jibx.runtime.JodaConvert.serializeUTCDateTime",
"org.jibx.runtime.JodaConvert.deserializeUTCDateTime", null),
buildFormat("DateTime.local", "org.joda.time.DateTime", true,
"org.jibx.runtime.JodaConvert.serializeZonedDateTime",
"org.jibx.runtime.JodaConvert.deserializeLocalDateTime", null),
buildFormat("DateTime.strict-local", "org.joda.time.DateTime", false,
"org.jibx.runtime.JodaConvert.serializeZonedDateTime",
"org.jibx.runtime.JodaConvert.deserializeStrictLocalDateTime", null),
buildFormat("DateTime.strict-UTC", "org.joda.time.DateTime", false,
"org.jibx.runtime.JodaConvert.serializeUTCDateTime",
"org.jibx.runtime.JodaConvert.deserializeStrictUTCDateTime", null),
//#j2me}
buildFormat("byte-array.default", "byte[]", true, "org.jibx.runtime.Utility.serializeBase64",
"org.jibx.runtime.Utility.deserializeBase64", null),
buildFormat("QName.default", "org.jibx.runtime.QName", true, "org.jibx.runtime.QName.serialize",
"org.jibx.runtime.QName.deserialize", null),
buildFormat("String.default", "java.lang.String", true, null, null, null),
buildFormat("Object.default", "java.lang.Object", true, null, null, null)
};
/**
* Default format builder.
*
* @param name
* @param type
* @param use
* @param sname
* @param dname
* @param dflt
* @return constructed format
*/
private static FormatElement buildFormat(String name, String type, boolean use, String sname, String dname,
String dflt) {
FormatElement format = new FormatElement();
format.setLabel(name);
format.setTypeName(type);
format.setDefaultFormat(use);
format.setSerializerName(sname);
format.setDeserializerName(dname);
format.setDefaultText(dflt);
return format;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/model/StructureElement.java 0000644 0001750 0001750 00000045130 11424466256 026553 0 ustar twerner twerner /*
Copyright (c) 2004-2010, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.model;
import java.util.ArrayList;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.util.IClass;
import org.jibx.util.StringArray;
/**
* Model component for structure element of binding definition.
*
* @author Dennis M. Sosnoski
*/
public class StructureElement extends StructureElementBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "map-as" },
StructureElementBase.s_allowedAttributes);
/** Mapping type name to use for this object. */
private String m_mapAsName;
/** Mapping qualified type name to use for this object. */
private QName m_mapAsQName;
/** Flag for structure has a concrete mapping, possibly indeterminant. */
private boolean m_hasMappingName;
/** Binding to use for this object. */
private TemplateElementBase m_effectiveMapping;
/**
* Default constructor.
*/
public StructureElement() {
super(STRUCTURE_ELEMENT);
}
/**
* Get name of mapping type.
*
* @return mapping type name (or null if none)
*/
public String getMapAsName() {
return m_mapAsName;
}
/**
* Set name of mapping type. This method changes the qualified name to
* match the mapping type.
*
* @param name mapping type name (or null if none)
*/
public void setMapAsName(String name) {
m_mapAsName = name;
m_mapAsQName = (name == null) ? null : new QName(name);
}
/**
* Get qualified name of mapping type.
*
* @return mapping qualified type name (or null if none)
*/
public QName getMapAsQName() {
return m_mapAsQName;
}
/**
* Set qualified name of mapping type. This method changes the mapping name
* to match the qualified name.
*
* @param name mapping qualified type name (or null if none)
*/
public void setMapAsQName(QName name) {
m_mapAsQName = name;
m_mapAsName = (name == null) ? null : name.toString();
}
/**
* Get actual type mapping. This call is only meaningful after validation.
*
* @return actual type mapping (or null if none)
*/
public TemplateElementBase getEffectiveMapping() {
return m_effectiveMapping;
}
/**
* Check if this structure defines a name directly.
*
* @return true if name defined, false if not
*/
public boolean hasDirectName() {
return super.hasName();
}
//
// Overrides of base class methods
/* (non-Javadoc)
* @see org.jibx.binding.model.IComponent#hasName()
*/
public boolean hasName() {
if (m_effectiveMapping instanceof MappingElementBase) {
if (((MappingElementBase)m_effectiveMapping).getName() != null) {
return true;
}
} else if (m_hasMappingName) {
return true;
}
return super.hasName();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IComponent#getName()
*/
public String getName() {
if (m_effectiveMapping instanceof MappingElementBase) {
String name = ((MappingElementBase)m_effectiveMapping).getName();
if (name != null) {
return name;
}
} else if (m_hasMappingName) {
return "#" + getType().getName();
}
return super.getName();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IComponent#getUri()
*/
public String getUri() {
if (m_effectiveMapping instanceof MappingElementBase) {
String uri = ((MappingElementBase)m_effectiveMapping).getUri();
if (uri != null) {
return uri;
}
}
return super.getUri();
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IComponent#hasAttribute()
*/
public boolean hasAttribute() {
if (hasName()) {
return false;
} else if (m_effectiveMapping != null) {
return m_effectiveMapping.name() == null &&
m_effectiveMapping.getAttributeComponents().size() > 0;
} else {
return super.hasAttribute();
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IComponent#hasContent()
*/
public boolean hasContent() {
if (hasName()) {
return true;
} else if (m_effectiveMapping != null) {
return m_effectiveMapping.name() != null ||
m_effectiveMapping.getContentComponents().size() > 0;
} else {
return super.hasContent();
}
}
/* (non-Javadoc)
* @see org.jibx.binding.model.IComponent#getType()
*/
public IClass getType() {
if (m_effectiveMapping == null) {
return super.getType();
} else {
return m_effectiveMapping.getHandledClass();
}
}
//
// Validation methods
/**
* JiBX access method to set mapping type name as qualified name.
*
* @param text mapping name text (null if none)
* @param ictx unmarshalling context
* @throws JiBXException on deserialization error
*/
private void setQualifiedMapAs(String text, IUnmarshallingContext ictx)
throws JiBXException {
m_mapAsName = text;
m_mapAsQName = QName.deserialize(text, ictx);
}
/**
* JiBX access method to get mapping type name as qualified name.
*
* @param ictx marshalling context
* @return mapping type name text (null if none)
* @throws JiBXException on deserialization error
*/
private String getQualifiedMapAs(IMarshallingContext ictx)
throws JiBXException {
return QName.serialize(m_mapAsQName, ictx);
}
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
* @exception JiBXException on unmarshalling error
*/
private void preSet(IUnmarshallingContext uctx) throws JiBXException {
validateAttributes(uctx, s_allowedAttributes);
}
/**
* Merge namespaces from an implicit context to those defined for a
* reference.
*
* @param defc context supplying namespaces to be merged
* @param addc context to be merged into
* @param vctx
*/
private void mergeNamespaces(DefinitionContext defc, DefinitionContext addc,
ValidationContext vctx) {
// check for namespaces present in context
ArrayList nss = defc.getNamespaces();
if (nss != null) {
// merge namespaces with those defined by containing mapping
for (int i = 0; i < nss.size(); i++) {
NamespaceElement ns = (NamespaceElement)nss.get(i);
ValidationProblem prob =
addc.addImpliedNamespace(ns, this);
if (prob != null) {
vctx.addProblem(prob);
}
}
}
}
/**
* Check for conflicts on namespace prefix usage. Abstract mappings may
* define namespaces, but the prefixes used by the abstract mappings must
* not conflict with those used at the point of reference. This allows the
* namespace definitions from the abstract mapping to be promoted to the
* containing element.
*
* @param base
* @param vctx
*/
private void checkNamespaceUsage(TemplateElementBase base,
ValidationContext vctx) {
// check for namespace definitions needing to be handled
if (base instanceof MappingElementBase &&
((MappingElementBase)base).isAbstract()) {
// merge namespaces defined within this mapping
DefinitionContext addc = vctx.getCurrentDefinitions();
DefinitionContext defc = base.getDefinitions();
if (defc != null) {
mergeNamespaces(defc, addc, vctx);
}
}
}
/**
* Classify child components as contributing attributes, content, or both.
* This method is needed to handle on-demand classification during
* validation. When a child component is another instance of this class, the
* method calls itself on the child component prior to checking the child
* component's contribution.
*
* @param vctx
*/
protected void classifyComponents(ValidationContext vctx) {
// check for classification already run
if (!isClassified()) {
// check if there's a mapping if used without children
// TODO: this isn't correct, but validation may not have reached
// this element yet so the context may not have been set. Clean
// this with parent link in all elements.
DefinitionContext dctx = vctx.getDefinitions();
if (children().size() == 0) {
if (m_mapAsQName == null) {
// make sure not just a name, allowed for skipped element
if (!isFlagOnly() &&
(hasProperty() || getDeclaredType() != null)) {
// see if this is using implicit marshaller/unmarshaller
if ((vctx.isInBinding() && getUnmarshallerName() == null) ||
(vctx.isOutBinding() && getMarshallerName() == null)) {
if (getUsing() == null) {
// check for specific type known
IClass type = getType();
if (type == null) {
vctx.addError("Internal error - null type");
} else if (!"java.lang.Object".equals(type.getName())) {
setMappingReference(vctx, dctx, type);
}
}
}
}
} else {
// find mapping by type name or class name
TemplateElementBase base =
dctx.getNamedTemplate(m_mapAsQName.toString());
if (base == null) {
base = dctx.getSpecificTemplate(m_mapAsName);
if (base == null) {
vctx.addFatal("No mapping with type name " +
m_mapAsQName.toString());
}
}
if (base != null) {
// make sure type is compatible
IClass type = getType();
if (vctx.isLookupSupported() && type != null) {
if (!type.isAssignable(base.getHandledClass()) &&
!base.getHandledClass().isAssignable(type)) {
vctx.addError("Object type " + type.getName() +
" is incompatible with binding for class " +
base.getClassName());
}
}
m_effectiveMapping = base;
// check for namespace conflicts
checkNamespaceUsage(base, vctx);
// set flag for mapping with name
m_hasMappingName = base instanceof MappingElementBase &&
!((MappingElementBase)base).isAbstract();
}
}
// classify mapping reference as providing content, attributes, or both
if (m_effectiveMapping instanceof MappingElement) {
MappingElement mapping = (MappingElement)m_effectiveMapping;
mapping.classifyComponents(vctx);
if (hasProperty()) {
mapping.verifyConstruction(vctx);
}
if (mapping.getName() == null) {
ArrayList attribs = EmptyArrayList.INSTANCE;
ArrayList contents = EmptyArrayList.INSTANCE;
if (mapping.getContentComponents().size() > 0) {
contents = new ArrayList();
contents.add(m_effectiveMapping);
}
if (mapping.getAttributeComponents().size() > 0) {
attribs = new ArrayList();
attribs.add(m_effectiveMapping);
}
setComponents(attribs, contents);
} else {
ArrayList contents = new ArrayList();
contents.add(m_effectiveMapping);
setComponents(EmptyArrayList.INSTANCE, contents);
}
}
} else if (m_mapAsName != null) {
vctx.addError("map-as attribute cannot be used with children");
}
}
// pass on call to superclass implementation
super.classifyComponents(vctx);
}
/* (non-Javadoc)
* @see org.jibx.binding.model.ElementBase#validate(org.jibx.binding.model.ValidationContext)
*/
public void validate(ValidationContext vctx) {
// set up child components and effective mapping
classifyComponents(vctx);
IClass type = getType();
if (type != null) {
// check each child component for compatible type
ArrayList children = children();
if (hasProperty() || getDeclaredType() != null) {
checkCompatibleChildren(vctx, type, children);
}
// check for only set-method supplied
if (!vctx.isOutBinding() && getField() == null &&
getGet() == null && getSet() != null) {
// no way to handle both elements and attributes
if (hasAttribute() && hasContent()) {
vctx.addError("Need way to load existing object instance " +
"to support combined attribute and element values");
} else {
vctx.addWarning("No way to load prior value - " +
"new instance will be created on each unmarshalling");
}
}
}
// make sure name is defined if nillable
if (isNillable() && !hasName()) {
vctx.addError("Need element name for nillable='true'");
}
super.validate(vctx);
}
/**
* Validate mapping reference.
*
* @param vctx validation context
* @param dctx definition context
* @param type referenced type
*/
private void setMappingReference(ValidationContext vctx,
DefinitionContext dctx, IClass type) {
// first try to find mapping by specific type
m_effectiveMapping = dctx.getNamedTemplate(type.getName());
if (m_effectiveMapping == null) {
// see if there's a mapping specific to the reference type
String tname = type.getName();
TemplateElementBase match = dctx.getSpecificTemplate(tname);
if (match != null) {
m_effectiveMapping = match;
if (match instanceof MappingElementBase) {
// set flag for name defined by mapping
MappingElementBase base = (MappingElementBase)match;
m_hasMappingName = !base.isAbstract();
checkNamespaceUsage(base, vctx);
// check name usage on non-abstract or base mapping
if (super.hasName()) {
if (!base.isAbstract()) {
vctx.addError("name attribute not allowed on concrete mapping reference", this);
} else if (base.getExtensionTypes().size() > 0) {
vctx.addError("name attribute not allowed on reference to mapping with extensions", this);
}
}
}
} else if (!dctx.isCompatibleTemplateType(type)) {
vctx.addFatal("No compatible mapping defined for type " + tname, this);
}
} else if (m_effectiveMapping instanceof MappingElementBase) {
// set flag for name defined by mapping
MappingElementBase base = (MappingElementBase)m_effectiveMapping;
m_hasMappingName = !base.isAbstract();
checkNamespaceUsage(base, vctx);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/util/ 0000755 0001750 0001750 00000000000 11526304016 022234 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/binding/util/ObjectStack.java 0000644 0001750 0001750 00000023727 10524427624 025316 0 ustar twerner twerner /*
Copyright (c) 2000-2006, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.util;
import java.lang.reflect.Array;
/**
* Growable Object stack with type specific access methods. This
* implementation is unsynchronized in order to provide the best possible
* performance for typical usage scenarios, so explicit synchronization must
* be implemented by a wrapper class or directly by the application in cases
* where instances are modified in a multithreaded environment.
*
* @author Dennis M. Sosnoski
*/
public class ObjectStack
{
/** Default initial array size. */
public static final int DEFAULT_SIZE = 8;
/** Size of the current array. */
protected int m_countLimit;
/** The number of values currently present in the stack. */
protected int m_countPresent;
/** Maximum size increment for growing array. */
protected int m_maximumGrowth;
/** The underlying array used for storing the data. */
protected Object[] m_baseArray;
/**
* Constructor with full specification.
*
* @param size number of Object values initially allowed in
* stack
* @param growth maximum size increment for growing stack
*/
public ObjectStack(int size, int growth) {
m_countLimit = size;
m_maximumGrowth = growth;
m_baseArray = new Object[size];
}
/**
* Constructor with initial size specified.
*
* @param size number of Object values initially allowed in
* stack
*/
public ObjectStack(int size) {
this(size, Integer.MAX_VALUE);
}
/**
* Default constructor.
*/
public ObjectStack() {
this(DEFAULT_SIZE);
}
/**
* Copy (clone) constructor.
*
* @param base instance being copied
*/
public ObjectStack(ObjectStack base) {
this(base.m_countLimit, base.m_maximumGrowth);
System.arraycopy(base.m_baseArray, 0, m_baseArray, 0,
base.m_countPresent);
m_countPresent = base.m_countPresent;
}
/**
* Constructor from array of strings.
*
* @param strings array of strings for initial contents
*/
public ObjectStack(Object[] strings) {
this(strings.length);
System.arraycopy(strings, 0, m_baseArray, 0, strings.length);
m_countPresent = strings.length;
}
/**
* Copy data after array resize. This just copies the entire contents of the
* old array to the start of the new array. It should be overridden in cases
* where data needs to be rearranged in the array after a resize.
*
* @param base original array containing data
* @param grown resized array for data
*/
private void resizeCopy(Object base, Object grown) {
System.arraycopy(base, 0, grown, 0, Array.getLength(base));
}
/**
* Discards values for a range of indices in the array. Checks if the
* values stored in the array are object references, and if so clears
* them. If the values are primitives, this method does nothing.
*
* @param from index of first value to be discarded
* @param to index past last value to be discarded
*/
private void discardValues(int from, int to) {
for (int i = from; i < to; i++) {
m_baseArray[i] = null;
}
}
/**
* Increase the size of the array to at least a specified size. The array
* will normally be at least doubled in size, but if a maximum size
* increment was specified in the constructor and the value is less than
* the current size of the array, the maximum increment will be used
* instead. If the requested size requires more than the default growth,
* the requested size overrides the normal growth and determines the size
* of the replacement array.
*
* @param required new minimum size required
*/
private void growArray(int required) {
int size = Math.max(required,
m_countLimit + Math.min(m_countLimit, m_maximumGrowth));
Object[] grown = new Object[size];
resizeCopy(m_baseArray, grown);
m_countLimit = size;
m_baseArray = grown;
}
/**
* Ensure that the array has the capacity for at least the specified
* number of values.
*
* @param min minimum capacity to be guaranteed
*/
public final void ensureCapacity(int min) {
if (min > m_countLimit) {
growArray(min);
}
}
/**
* Push a value on the stack.
*
* @param value value to be added
*/
public void push(Object value) {
int index = getAddIndex();
m_baseArray[index] = value;
}
/**
* Pop a value from the stack.
*
* @return value from top of stack
* @exception ArrayIndexOutOfBoundsException on attempt to pop empty stack
*/
public Object pop() {
if (m_countPresent > 0) {
Object value = m_baseArray[--m_countPresent];
m_baseArray[m_countPresent] = null;
return value;
} else {
throw new ArrayIndexOutOfBoundsException
("Attempt to pop empty stack");
}
}
/**
* Pop multiple values from the stack. The last value popped is the
* one returned.
*
* @param count number of values to pop from stack (must be strictly
* positive)
* @return value from top of stack
* @exception ArrayIndexOutOfBoundsException on attempt to pop past end of
* stack
*/
public Object pop(int count) {
if (count < 0) {
throw new IllegalArgumentException("Count must be greater than 0");
} else if (m_countPresent >= count) {
m_countPresent -= count;
Object value = m_baseArray[m_countPresent];
discardValues(m_countPresent, m_countPresent + count);
return value;
} else {
throw new ArrayIndexOutOfBoundsException
("Attempt to pop past end of stack");
}
}
/**
* Copy a value from the stack. This returns a value from within
* the stack without modifying the stack.
*
* @param depth depth of value to be returned
* @return value from stack
* @exception ArrayIndexOutOfBoundsException on attempt to peek past end of
* stack
*/
public Object peek(int depth) {
if (m_countPresent > depth) {
return m_baseArray[m_countPresent - depth - 1];
} else {
throw new ArrayIndexOutOfBoundsException
("Attempt to peek past end of stack");
}
}
/**
* Copy top value from the stack. This returns the top value without
* removing it from the stack.
*
* @return value at top of stack
* @exception ArrayIndexOutOfBoundsException on attempt to peek empty stack
*/
public Object peek() {
return peek(0);
}
/**
* Constructs and returns a simple array containing the same data as held
* in this stack. Note that the items will be in reverse pop order, with
* the last item to be popped from the stack as the first item in the
* array.
*
* @return array containing a copy of the data
*/
public Object[] toArray() {
Object[] copy = new Object[m_countPresent];
System.arraycopy(m_baseArray, 0, copy, 0, m_countPresent);
return copy;
}
/**
* Duplicates the object with the generic call.
*
* @return a copy of the object
*/
public Object clone() {
return new ObjectStack(this);
}
/**
* Gets the array offset for appending a value to those in the stack.
* If the underlying array is full, it is grown by the appropriate size
* increment so that the index value returned is always valid for the
* array in use by the time of the return.
*
* @return index position for added element
*/
private int getAddIndex() {
int index = m_countPresent++;
if (m_countPresent > m_countLimit) {
growArray(m_countPresent);
}
return index;
}
/**
* Get the number of values currently present in the stack.
*
* @return count of values present
*/
public int size() {
return m_countPresent;
}
/**
* Check if stack is empty.
*
* @return true if stack empty, false if not
*/
public boolean isEmpty() {
return m_countPresent == 0;
}
/**
* Set the stack to the empty state.
*/
public void clear() {
discardValues(0, m_countPresent);
m_countPresent = 0;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/util/ArrayMap.java 0000644 0001750 0001750 00000007442 10524407520 024623 0 ustar twerner twerner /*
Copyright (c) 2003-2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.util;
import java.util.ArrayList;
import java.util.HashMap;
/**
* Array with reverse mapping from values to indices. This operates as the
* combination of an array with ordinary int indices and a hashmap from values
* back to the corresponding index position. Values are assured to be unique.
*
* @author Dennis M. Sosnoski
*/
public class ArrayMap
{
/** Array of values. */
private ArrayList m_array;
/** Map from values to indices. */
private HashMap m_map;
/**
* Default constructor.
*/
public ArrayMap() {
m_array = new ArrayList();
m_map = new HashMap();
}
/**
* Constructor with initial capacity supplied.
*
* @param size initial capacity for array map
*/
public ArrayMap(int size) {
m_array = new ArrayList(size);
m_map = new HashMap(size);
}
/**
* Get value for index. The index must be within the valid range (from 0 to
* one less than the number of values present).
*
* @param index number to be looked up
* @return value at that index position
*/
public Object get(int index) {
return m_array.get(index);
}
/**
* Find existing object. If the supplied value object is present in the
* array map its index position is returned.
*
* @param obj value to be found
* @return index number assigned to value, or -1 if not found
*/
public int find(Object obj) {
Integer index = (Integer)m_map.get(obj);
if (index == null) {
return -1;
} else {
return index.intValue();
}
}
/**
* Add object. If the supplied value object is already present in the array
* map the existing index position is returned.
*
* @param obj value to be added
* @return index number assigned to value
*/
public int findOrAdd(Object obj) {
Integer index = (Integer)m_map.get(obj);
if (index == null) {
index = IntegerCache.getInteger(m_array.size());
m_map.put(obj, index);
m_array.add(obj);
}
return index.intValue();
}
/**
* Get count of values present.
*
* @return number of values in array map
*/
public int size() {
return m_array.size();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/util/MultipleValueMap.java 0000644 0001750 0001750 00000021704 11124147712 026333 0 ustar twerner twerner /*
Copyright (c) 2006-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.util;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Set;
import org.jibx.binding.model.EmptyArrayList;
/**
* Map supporting multiple values for a single key. The multiple value concept
* doesn't really fit with the standard collections idea of a map, so this
* provides its own variation of a map interface rather than extend the standard
* one.
*
* @author Dennis M. Sosnoski
*/
public class MultipleValueMap
{
/** Backing map from key to value or array of values. */
private final HashMap m_backingMap;
/** Actual number of values (not keys) present in map. */
private int m_valueCount;
/** Last lookup key (null if none, or if value changed). */
private Object m_lastKey;
/** Last lookup value (null if none, or if value changed). */
private Object m_lastValue;
/**
* Constructor.
*/
public MultipleValueMap() {
super();
m_backingMap = new HashMap();
}
/**
* Internal cached lookup.
*
* @param key
* @return value
*/
private Object getMapped(Object key) {
if (key != m_lastKey) {
m_lastKey = key;
m_lastValue = m_backingMap.get(key);
}
return m_lastValue;
}
/**
* Clear all entries.
*/
public void clear() {
m_backingMap.clear();
m_valueCount = 0;
}
/**
* Get number of values present for key.
*
* @param key
* @return value count
*/
public int getCount(Object key) {
Object obj = getMapped(key);
if (obj instanceof MultipleValueList) {
return ((MultipleValueList)obj).size();
} else if (obj == null) {
return 0;
} else {
return 1;
}
}
/**
* Get indexed value for key.
*
* @param key
* @param index
* @return value
*/
public Object get(Object key, int index) {
Object obj = getMapped(key);
if (obj instanceof MultipleValueList) {
return ((MultipleValueList)obj).get(index);
} else if (obj == null) {
throw new IndexOutOfBoundsException("No value present for key");
} else if (index == 0) {
return obj;
} else {
throw new IndexOutOfBoundsException("Only one value present for key");
}
}
/**
* Add value for key.
*
* @param key
* @param value
*/
public void add(Object key, Object value) {
// first force caching of current value
getMapped(key);
// update value as appropriate
if (m_lastValue == null) {
m_backingMap.put(key, value);
m_lastValue = value;
} else if (m_lastValue instanceof MultipleValueList) {
((MultipleValueList)m_lastValue).add(value);
} else {
MultipleValueList list = new MultipleValueList();
list.add(m_lastValue);
list.add(value);
m_backingMap.put(key, list);
m_lastValue = list;
}
m_valueCount++;
}
/**
* Get all values for key. This returns the value(s) from the map and
* returns them in the form of a list.
*
* @param key
* @return list of values
*/
public ArrayList get(Object key) {
Object obj = m_backingMap.get(key);
if (obj instanceof MultipleValueList) {
return (MultipleValueList)obj;
} else if (obj == null) {
return EmptyArrayList.INSTANCE;
} else {
MultipleValueList list = new MultipleValueList();
list.add(obj);
return list;
}
}
/**
* Extract all values for key. This removes the value(s) from the map and
* returns them in the form of a list.
*
* @param key
* @return prior list of values
*/
public ArrayList extract(Object key) {
ArrayList result = get(key);
m_backingMap.remove(key);
return result;
}
/**
* Get number of keys.
*
* @return key count
*/
public int keySize() {
return m_backingMap.size();
}
/**
* Get number of values.
*
* @return value count
*/
public int valueSize() {
return m_valueCount;
}
/**
* Get iterator over only the multiple-valued keys present in the map.
*
* @return iterator
*/
public Iterator multipleIterator() {
return new MultipleIterator();
}
//
// Delegated methods
/**
* Check key present in map.
*
* @param key
* @return key present flag
*/
public boolean containsKey(Object key) {
return m_backingMap.containsKey(key);
}
/**
* Check if map is empty.
*
* @return empty flag
*/
public boolean isEmpty() {
return m_backingMap.isEmpty();
}
/**
* Get key set.
*
* @return set of keys
*/
public Set keySet() {
return m_backingMap.keySet();
}
/**
* List used for multiple values. This is just a marker, so that the actual
* values can be anything at all (including lists).
*/
private static class MultipleValueList extends ArrayList {
public MultipleValueList() {}
}
/**
* Iterator for only the multiple-valued keys in the map.
*/
public class MultipleIterator implements Iterator
{
/** Current key value has been consumed flag. */
private boolean m_isConsumed;
/** Current key, null if past end. */
private Object m_currentKey;
/** Iterator through keys present in map. */
private Iterator m_keyIterator;
/**
* Constructor. This initializes the key iterator and next key values.
*/
protected MultipleIterator() {
m_keyIterator = keySet().iterator();
m_isConsumed = true;
}
/**
* Advance to next multiple-valued key in map.
*/
private void advance() {
if (m_isConsumed) {
m_isConsumed = false;
m_currentKey = null;
while (m_keyIterator.hasNext()) {
Object key = m_keyIterator.next();
if (getCount(key) > 1) {
m_currentKey = key;
break;
}
}
}
}
/**
* Check for another multiple-valued key present.
*
* @return true if present, false if not
*/
public boolean hasNext() {
advance();
return m_currentKey != null;
}
/**
* Get the next multiple-valued key in map. This returns the current
* next key, advancing to the next next key.
*
* @return next multiple-valued key
*/
public Object next() {
advance();
if (m_currentKey == null) {
throw new NoSuchElementException("Past end of list");
} else {
m_isConsumed = true;
return m_currentKey;
}
}
/**
* Remove current multiple-valued key.
*/
public void remove() {
m_keyIterator.remove();
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/util/SparseStack.java 0000644 0001750 0001750 00000006756 10524427624 025350 0 ustar twerner twerner /*
Copyright (c) 2005-2006, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.util;
import org.jibx.runtime.IntStack;
/**
* Stack for values that depend on the level of nesting, where only some of the
* levels change the current value.
*
* @author Dennis M. Sosnoski
*/
public class SparseStack
{
/** Current item. */
private Object m_current;
/** Current nesting level. */
private int m_level;
/** Levels with different items (paired with m_items stack). */
private IntStack m_levels;
/** Stack of different items (paired with m_levels stack). */
private ObjectStack m_items;
/**
* Constructor with initial value.
*
* @param current initial value
*/
public SparseStack(Object current) {
// initialize so peek always works
m_levels = new IntStack();
m_levels.push(-1);
m_items = new ObjectStack();
m_items.push(current);
m_current = current;
}
/**
* Constructor with no initial value.
*/
public SparseStack() {
this(null);
}
/**
* Get current object.
*
* @return current
*/
public Object getCurrent() {
return m_current;
}
/**
* Set current object.
*
* @param obj set the current object
*/
public void setCurrent(Object obj) {
m_current = obj;
}
/**
* Enter a level of nesting.
*/
public void enter() {
if (m_current != m_items.peek()) {
m_levels.push(m_level);
m_items.push(m_current);
}
m_level++;
}
/**
* Exit a level of nesting with changed item returned.
*
* @return item that was active until this exit, or null if
* same item still active
*/
public Object exit() {
m_level--;
if (m_level == m_levels.peek()) {
Object obj = m_current;
m_levels.pop();
m_current = m_items.pop();
return obj;
} else {
return null;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/util/IntegerCache.java 0000644 0001750 0001750 00000006356 10210703674 025434 0 ustar twerner twerner /*
Copyright (c) 2003-2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.util;
/**
* Cache of Integer values. This is designed on the assumption that
* clients will start with zero and work their way up from there. By holding
* created instances in an array it allows for full reuse.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public abstract class IntegerCache
{
/** Initial set of index values supported. */
private static Integer[] s_integers =
{
new Integer(0), new Integer(1), new Integer(2), new Integer(3),
new Integer(4), new Integer(5), new Integer(6), new Integer(7)
};
/**
* Get Integer for value.
*
* @param value non-negative integer value
* @return corresponding Integer value
*/
public static Integer getInteger(int value) {
if (value >= s_integers.length) {
// Note that in multithreaded operation there's a chance of two
// threads getting in a race condition here, but the worst that
// can happen is that the array gets extended more than it needs
// to be. Threads just using the array are safe - though if they
// get an old version they may again extend the array
// unnecessarily.
synchronized(IntegerCache.class) {
int size = s_integers.length * 3 / 2;
if (size <= value) {
size = value + 1;
}
Integer[] ints = new Integer[size];
System.arraycopy(s_integers, 0, ints, 0, s_integers.length);
for (int i = 0; i < size; i++) {
ints[i] = new Integer(i);
}
s_integers = ints;
}
}
return s_integers[value];
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/ 0000755 0001750 0001750 00000000000 11526304026 022016 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/DirectProperty.java 0000644 0001750 0001750 00000016607 10435324110 025644 0 ustar twerner twerner /*
Copyright (c) 2003-2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.jibx.binding.classes.*;
import org.jibx.runtime.JiBXException;
/**
* Property reference with marshaller and unmarshaller. This handles loading
* and storing the property value, calling the supplied marshaller and
* unmarshaller for all else.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class DirectProperty implements IComponent
{
/** Property definition. */
private final PropertyDefinition m_property;
/** Property value direct binding. */
private final DirectObject m_direct;
/**
* Constructor.
*
* @param prop property definition
* @param direct object direct binding information
*/
public DirectProperty(PropertyDefinition prop, DirectObject direct) {
m_property = prop;
m_direct = direct;
}
//
// IComponent interface method definitions
public boolean isOptional() {
return m_property.isOptional();
}
public boolean hasAttribute() {
return false;
}
public void genAttrPresentTest(ContextMethodBuilder mb)
throws JiBXException {
throw new IllegalStateException
("Internal error - no attributes allowed");
}
public void genAttributeUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
throw new IllegalStateException
("Internal error - no attributes allowed");
}
public void genAttributeMarshal(ContextMethodBuilder mb)
throws JiBXException {
throw new IllegalStateException
("Internal error - no attributes allowed");
}
public boolean hasContent() {
return true;
}
public void genContentPresentTest(ContextMethodBuilder mb)
throws JiBXException {
m_direct.genContentPresentTest(mb);
}
public void genContentUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
// check type of property binding
if (m_property.isImplicit()) {
// load null to force create of new object for item in collection
mb.appendACONST_NULL();
m_direct.genContentUnmarshal(mb);
} else if (m_property.isThis()) {
// load existing object to unmarshal for "this" reference
mb.loadObject();
m_direct.genContentUnmarshal(mb);
} else {
// start by generating code to load owning object so can finish by
// storing to property
mb.loadObject();
BranchWrapper ifpres = null;
BranchWrapper tosave = null;
if (m_property.isOptional()) {
// generate code to check presence for the case of an optional
// item, with branch if so; if not present, set a null value
// with branch to be targeted at property store.
m_direct.genContentPresentTest(mb);
ifpres = mb.appendIFNE(this);
mb.appendACONST_NULL();
tosave = mb.appendUnconditionalBranch(this);
}
// generate unmarshalling code for not optional, or optional and
// present; get existing instance or create a new one and handle
// attribute unmarshalling
mb.targetNext(ifpres);
mb.loadObject();
m_property.genLoad(mb);
m_direct.genContentUnmarshal(mb);
mb.appendCreateCast(m_property.getSetValueType());
mb.targetNext(tosave);
m_property.genStore(mb);
}
}
public void genContentMarshal(ContextMethodBuilder mb)
throws JiBXException {
// check type of property binding
if (m_property.isImplicit()) {
// marshal object already loaded on stack
m_direct.genContentMarshal(mb);
} else if (m_property.isThis()) {
// load object to marshal for "this" reference
mb.loadObject();
m_direct.genContentMarshal(mb);
} else {
// start by generating code to load the actual object reference
mb.loadObject();
m_property.genLoad(mb);
BranchWrapper missing = null;
if (m_property.isOptional()) {
// generate code to check null for the case of an optional item,
// with branch if so; if present, just reload object and fall
// through.
missing = mb.appendIFNULL(this);
mb.loadObject();
m_property.genLoad(mb);
}
// generate code for actual marshalling if not optional, or optional
// and nonnull; then finish by setting target for optional with
// null value case
m_direct.genContentMarshal(mb);
mb.targetNext(missing);
}
}
public void genNewInstance(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no instance creation");
}
public String getType() {
return m_property.getTypeName();
}
public boolean hasId() {
return false;
}
public void genLoadId(ContextMethodBuilder mb) throws JiBXException {
throw new IllegalStateException("Internal error - no id defined");
}
public NameDefinition getWrapperName() {
return m_direct.getWrapperName();
}
public void setLinkages() throws JiBXException {
m_direct.setLinkages();
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
if (m_property == null) {
System.out.println("direct implicit property");
} else {
System.out.println("direct property using " +
m_property.toString());
}
m_direct.print(depth+1);
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/NestedStructure.java 0000644 0001750 0001750 00000042531 11155012462 026027 0 ustar twerner twerner /*
Copyright (c) 2003-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import java.util.ArrayList;
import org.jibx.binding.classes.*;
import org.jibx.runtime.JiBXException;
/**
* Structure binding definition. This handles one or more child components,
* which may be ordered or unordered.
*
* @author Dennis M. Sosnoski
*/
public class NestedStructure extends NestedBase
{
//
// Method definitions used in code generation
private static final String CHECK_ISSTART_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.isStart";
private static final String CHECK_ISSTART_SIGNATURE = "()Z";
private static final String SKIP_ELEMENT_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.skipElement";
private static final String SKIP_ELEMENT_SIGNATURE = "()V";
private static final String THROW_EXCEPTION_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.throwNameException";
private static final String THROW_EXCEPTION_SIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V";
//
// Instance data
/** Child supplying ID for bound class. */
private IComponent m_idChild;
/** Flag for choice of child content (used by subclasses). */
protected final boolean m_isChoice;
/** Flag for duplicate values allowed when unmarshalling unordered group. */
private final boolean m_allowDuplicates;
/** Flag for structure has associated object. */
private boolean m_hasObject;
/** Flag for already linked (to avoid multiple passes). */
private boolean m_isLinked;
/**
* Constructor.
*
* @param parent containing binding definition context
* @param objc current object context
* @param ord ordered content flag
* @param choice choice content flag
* @param flex flexible element handling flag
* @param ctx define context for structure flag
* @param hasobj has associated object flag
* @param dupl allow duplicates in unordered group flag
*/
public NestedStructure(IContainer parent, IContextObj objc,
boolean ord, boolean choice, boolean flex, boolean ctx,
boolean hasobj, boolean dupl) {
super(parent, objc, ord, flex, ctx);
m_isChoice = choice;
m_hasObject = hasobj;
m_allowDuplicates = dupl;
}
/**
* Set the object context.
*
* @param objc object context
*/
public void setObjectContext(IContextObj objc) {
m_hasObject = false;
}
/**
* Check if the structure is just a mapping reference. This is used to
* short-circuit the code generation to avoid multiple layers of binding
* methods. As written, the result is only valid prior to a call to
* {@link #setLinkages()}.
*
* @return true if a mapping reference, false if
* not
*/
public boolean isMappingReference() {
return m_contents.size() == 1 &&
m_contents.get(0) instanceof MappingReference;
}
//
// IComponent interface method definitions
public void genNewInstance(ContextMethodBuilder mb) {
if (isMappingReference()) {
throw new IllegalStateException
("Internal error - no instance creation");
}
}
public boolean hasAttribute() {
return m_attributes != null && m_attributes.size() > 0;
}
public void genAttrPresentTest(ContextMethodBuilder mb)
throws JiBXException {
if (m_attributes != null && m_attributes.size() > 0) {
// if single possibility just test it directly
int count = m_attributes.size();
if (count == 1) {
((IComponent)m_attributes.get(0)).genAttrPresentTest(mb);
} else {
// generate code for chained test with branches to found exit
BranchWrapper[] tofound = new BranchWrapper[count];
for (int i = 0; i < count; i++) {
IComponent comp = (IComponent)m_attributes.get(i);
comp.genAttrPresentTest(mb);
tofound[i] = mb.appendIFNE(this);
}
// fall off end of loop to push "false" on stack and jump to end
mb.appendICONST_0();
BranchWrapper toend = mb.appendUnconditionalBranch(this);
// generate found target to push "true" on stack and continue
for (int i = 0; i < count; i++) {
mb.targetNext(tofound[i]);
}
mb.appendICONST_1();
mb.targetNext(toend);
}
} else {
throw new IllegalStateException
("Internal error - no attributes present");
}
}
public void genAttributeUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_attributes != null && m_attributes.size() > 0) {
for (int i = 0; i < m_attributes.size(); i++) {
IComponent attr = (IComponent)m_attributes.get(i);
attr.genAttributeUnmarshal(mb);
}
} else {
throw new IllegalStateException
("Internal error - no attributes present");
}
}
public void genAttributeMarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_attributes != null && m_attributes.size() > 0) {
for (int i = 0; i < m_attributes.size(); i++) {
IComponent attr = (IComponent)m_attributes.get(i);
attr.genAttributeMarshal(mb);
}
} else {
throw new IllegalStateException
("Internal error - no attributes present");
}
}
public boolean hasContent() {
return m_contents.size() > 0;
}
public void genContentUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_contents.size() > 0) {
// check for ordered or unordered content
if (m_isOrdered) {
// should never get here on choice, but just in case
if (m_isChoice) {
throw new IllegalStateException("Internal error - generation model uses ordered choice");
}
// just generate unmarshal code for each component in order
for (int i = 0; i < m_contents.size(); i++) {
IComponent child = (IComponent)m_contents.get(i);
child.genContentUnmarshal(mb);
}
} else {
// start by finding the number of required elements
int count = m_contents.size();
int nreq = 0;
boolean dupl = m_allowDuplicates;
if (m_isChoice) {
dupl = true;
} else {
for (int i = 0; i < count; i++) {
if (!((IComponent)m_contents.get(i)).isOptional()) {
nreq++;
}
}
}
// create array for tracking elements seen
boolean useflag = nreq > 0 || !dupl;
if (useflag) {
mb.appendLoadConstant(count);
mb.appendCreateArray("boolean");
mb.defineSlot(this, ClassItem.typeFromName("boolean[]"));
}
// generate unmarshal loop code that checks for each component,
// branching to the next component until one is found and
// exiting the loop only when no component is matched (or in
// the case of flexible unmarshalling, only exiting the loop
// when the enclosing end tag is seen). this uses the array(s)
// of booleans to track elements seen and detect duplicates.
BranchWrapper link = null;
// TODO: initialize default values
BranchTarget first = mb.appendTargetNOP();
BranchWrapper[] toends;
if (m_isChoice) {
toends = new BranchWrapper[count+1];
} else {
toends = new BranchWrapper[1];
}
for (int i = 0; i < count; i++) {
// start with basic test code
if (link != null) {
mb.targetNext(link);
}
IComponent child = (IComponent)m_contents.get(i);
child.genContentPresentTest(mb);
link = mb.appendIFEQ(this);
// check for duplicate (if enforced)
if (!dupl) {
genFlagTest(true, i, "Duplicate element ",
child.getWrapperName(), mb);
}
// set flag for element seen
if (useflag && !(child.isOptional() && dupl)) {
mb.appendLoadLocal(mb.getSlot(this));
mb.appendLoadConstant(i);
mb.appendLoadConstant(1);
mb.appendASTORE("boolean");
}
// generate actual unmarshalling code
child.genContentUnmarshal(mb);
BranchWrapper next = mb.appendUnconditionalBranch(this);
if (m_isChoice) {
toends[i+1] = next;
} else {
next.setTarget(first, mb);
}
}
// handle comparison fall through depending on flexible flag
if (m_isFlexible) {
if (link != null) {
// exit loop if not positioned at element start
mb.targetNext(link);
mb.loadContext();
mb.appendCallVirtual(CHECK_ISSTART_NAME,
CHECK_ISSTART_SIGNATURE);
toends[0] = mb.appendIFEQ(this);
// ignore unknown element and loop back to start
mb.loadContext();
mb.appendCallVirtual(SKIP_ELEMENT_NAME,
SKIP_ELEMENT_SIGNATURE);
mb.appendUnconditionalBranch(this).setTarget(first, mb);
}
} else {
// set final test failure branch to fall through loop
toends[0] = link;
}
// patch all branches that exit loop
mb.targetNext(toends);
// handle required element present tests
if (nreq > 0) {
for (int i = 0; i < count; i++) {
IComponent child = (IComponent)m_contents.get(i);
if (!child.isOptional()) {
genFlagTest(false, i, "Missing required element ",
child.getWrapperName(), mb);
}
}
}
mb.freeSlot(this);
}
} else {
throw new IllegalStateException
("Internal error - no content present");
}
}
/**
* Helper method to generate test code for value in boolean array. If the
* test fails, the generated code throws an exception with the appropriate
* error message.
*
* @param cond flag setting resulting in exception
* @param pos position of element in list of child components
* @param msg basic error message when test fails
* @param name
* @param mb
*/
private void genFlagTest(boolean cond, int pos, String msg,
NameDefinition name, ContextMethodBuilder mb) {
// generate code to load array item value
mb.appendLoadLocal(mb.getSlot(this));
mb.appendLoadConstant(pos);
mb.appendALOAD("boolean");
// append branch for case where test is passed
BranchWrapper ifgood;
if (cond) {
ifgood = mb.appendIFEQ(this);
} else {
ifgood = mb.appendIFNE(this);
}
// generate exception for test failed
mb.loadContext();
mb.appendLoadConstant(msg);
if (name == null) {
mb.appendACONST_NULL();
mb.appendLoadConstant("(unknown name, position " + pos +
" in binding structure)");
} else {
name.genPushUriPair(mb);
}
mb.appendCallVirtual(THROW_EXCEPTION_NAME, THROW_EXCEPTION_SIGNATURE);
// set target for success branch on test
mb.targetNext(ifgood);
}
public void genContentMarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_contents.size() > 0) {
for (int i = 0; i < m_contents.size(); i++) {
IComponent content = (IComponent)m_contents.get(i);
content.genContentMarshal(mb);
}
} else {
throw new IllegalStateException
("Internal error - no content present");
}
}
public String getType() {
if (m_hasObject) {
return super.getType();
} else if (m_attributes != null && m_attributes.size() > 0) {
return ((IComponent)m_attributes.get(0)).getType();
} else if (m_contents.size() > 0) {
return ((IComponent)m_contents.get(0)).getType();
} else {
throw new IllegalStateException("Internal error - " +
"no type defined for structure");
}
}
public boolean hasId() {
return m_idChild != null;
}
public void genLoadId(ContextMethodBuilder mb) throws JiBXException {
if (m_idChild == null) {
throw new IllegalStateException("No ID child defined");
} else {
m_idChild.genLoadId(mb);
}
}
public void setLinkages() throws JiBXException {
if (!m_isLinked) {
// set flag first in case of recursive reference
m_isLinked = true;
// process all child components to link and sort by type
int i = 0;
while (i < m_contents.size()) {
IComponent comp = (IComponent)m_contents.get(i);
comp.setLinkages();
if (comp.hasAttribute()) {
if (m_attributes == null) {
m_attributes = new ArrayList();
}
m_attributes.add(comp);
}
if (!comp.hasContent()) {
m_contents.remove(i);
} else {
i++;
}
}
}
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.print("structure " +
(m_isChoice ? "choice" : (m_isOrdered ? "ordered" : "unordered")));
if (m_allowDuplicates) {
System.out.print(", duplicates allowed");
}
if (isFlexible()) {
System.out.print(", flexible");
}
if (m_idChild != null) {
System.out.print(" (ID)");
}
System.out.println();
for (int i = 0; i < m_contents.size(); i++) {
IComponent comp = (IComponent)m_contents.get(i);
comp.print(depth+1);
}
if (m_attributes != null) {
for (int i = 0; i < m_attributes.size(); i++) {
IComponent comp = (IComponent)m_attributes.get(i);
comp.print(depth+1);
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/ILinkable.java 0000644 0001750 0001750 00000004605 11032774166 024530 0 ustar twerner twerner /*
Copyright (c) 2003-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.jibx.runtime.JiBXException;
/**
* Linkable component interface definition. This is extended by both the basic
* {@link IComponent} component interface and the {@link IMapping} mapping
* interface.
*
* @author Dennis M. Sosnoski
*/
public interface ILinkable
{
/**
* Establish and validate linkages between binding components. This is
* called after the basic binding structures have been set up. All linkages
* between components must be resolved by this method, in order to prevent
* problems due to the order of definitions between components. This implies
* that each component must in turn call the same method for each child
* component. None of the other method calls defined by this interface are
* valid until after this call.
*
* @throws JiBXException if error in configuration
*/
void setLinkages() throws JiBXException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/ITypeBinding.java 0000644 0001750 0001750 00000014616 11031247476 025224 0 ustar twerner twerner /*
* Copyright (c) 2008, Dennis M. Sosnoski. 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. Neither the name of JiBX nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 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 OWNER 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.jibx.binding.def;
import org.jibx.runtime.JiBXException;
/**
* Interface for accessing methods used in a type binding. All the methods
* accessed by this interface are public, static, methods.
*
* @author Dennis M. Sosnoski
*/
public interface ITypeBinding
{
/**
* Get the method which creates an instance of the bound class if one does
* not already exist. This method takes a reference to the bound type as the
* first parameter and the unmarshalling context as the second parameter. If
* the passed reference is non-null that reference will
* simply be returned; otherwise, a new instance will be created and
* returned. This method also handles any appropriate pre-set processing for
* the instance.
*
* @return create method, or null if none
* @throws JiBXException on error in code generation
*/
String getCreateMethod() throws JiBXException;
/**
* Get the method which handles unmarshalling completion. This method takes
* a reference to the bound type as the first parameter and the
* unmarshalling context as the second parameter. There is no return value
* from the method.
*
* @return complete method, or null if none
* @throws JiBXException on error in code generation
*/
String getCompleteMethod() throws JiBXException;
/**
* Get the method which handles preparation for marshalling an instance.
* This method takes a reference to the bound type as the first parameter
* and the unmarshalling context as the second parameter. There is no return
* value from the method.
*
* @return prepare method, or null if none
* @throws JiBXException on error in code generation
*/
String getPrepareMethod() throws JiBXException;
/**
* Get the method which checks attributes to determine if an instance is
* present. This method takes the unmarshalling context as the only
* parameter. It returns true if an attribute of the mapping
* is found, false if not.
*
* @return test method, or null if none
* @throws JiBXException on error in code generation
*/
String getAttributePresentTestMethod() throws JiBXException;
/**
* Get the method which unmarshals attributes into an instance. This method
* takes a reference to the bound type as the first parameter and the
* unmarshalling context as the second parameter. The return value is the
* unmarshalled instance, which may not be the same instance as was passed
* as a parameter.
*
* @return attribute unmarshal method, or null if none
* @throws JiBXException on error in code generation
*/
String getAttributeUnmarshalMethod() throws JiBXException;
/**
* Get the method which marshals attributes from an instance. This method
* takes a reference to the bound type as the first parameter and the
* unmarshalling context as the second parameter. There is no return value
* from the method.
*
* @return attribute marshal method, or null if none
* @throws JiBXException on error in code generation
*/
String getAttributeMarshalMethod() throws JiBXException;
/**
* Get the method which checks child elements to determine if an instance is
* present. This method takes the unmarshalling context as the only
* parameter. It returns true if an attribute of the mapping
* is found, false if not.
*
* @return content test method, or null if none
* @throws JiBXException on error in code generation
*/
String getContentPresentTestMethod() throws JiBXException;
/**
* Get the method which unmarshals child elements and character data content
* into an instance. This method takes a reference to the bound type as the
* first parameter and the unmarshalling context as the second parameter.
* There is no return value from the method. The return value is the
* unmarshalled instance, which may not be the same instance as was passed
* as a parameter.
*
* @return content unmarshal method, or null if none
* @throws JiBXException on error in code generation
*/
String getContentUnmarshalMethod() throws JiBXException;
/**
* Get the method which marshals child elements and character data content
* from an instance. This method takes a reference to the bound type as the
* first parameter and the unmarshalling context as the second parameter.
* There is no return value from the method.
*
* @return content marshal method, or null if none
* @throws JiBXException on error in code generation
*/
String getContentMarshalMethod() throws JiBXException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/ValueChild.java 0000644 0001750 0001750 00000112561 11175704114 024711 0 ustar twerner twerner /*
Copyright (c) 2003-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.apache.bcel.Constants;
import org.apache.bcel.generic.*;
import org.jibx.binding.classes.*;
import org.jibx.runtime.JiBXException;
/**
* Attribute or simple content value definition from binding. This organizes
* information for anything that can be converted to and from a simple
* String. Content values include both elements with only character
* data content and text, as character data content or CDATA sections.
*
* @author Dennis M. Sosnoski
*/
public class ValueChild implements IComponent
{
//
// Ident type enumeration.
/*package*/ static final int DIRECT_IDENT = 0;
/*package*/ static final int AUTO_IDENT = 1;
/*package*/ static final int DEF_IDENT = 2;
/*package*/ static final int REF_IDENT = 3;
//
// Value style enumeration.
/*package*/ static final int ATTRIBUTE_STYLE = 0;
/*package*/ static final int ELEMENT_STYLE = 1;
/*package*/ static final int TEXT_STYLE = 2;
/*package*/ static final int CDATA_STYLE = 3;
//
// Constants for unmarshalling.
/** Prefix used for backfill classes. */
private static final String BACKFILL_SUFFIX = "_backfill_";
private static final String[] BACKFILL_INTERFACES =
{
"org.jibx.runtime.impl.BackFillReference"
};
private static final String BACKFILL_METHODNAME = "backfill";
private static final Type[] BACKFILL_METHODARGS =
{
Type.OBJECT
};
private static final String BOUNDREF_NAME = "m_obj";
private static final String CHECK_ELEMENT_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.isAt";
private static final String CHECK_ATTRIBUTE_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.hasAttribute";
private static final String CHECK_SIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;)Z";
private static final String UNMARSHAL_DEFREF_ATTR_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.attributeExistingIDREF";
private static final String UNMARSHAL_DEFREF_ELEM_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.parseElementExistingIDREF";
private static final String UNMARSHAL_FWDREF_ATTR_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.attributeForwardIDREF";
private static final String UNMARSHAL_FWDREF_ELEM_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.parseElementForwardIDREF";
private static final String UNMARSHAL_DEFREF_SIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;I)Ljava/lang/Object;";
private static final String REGISTER_BACKFILL_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.registerBackFill";
private static final String REGISTER_BACKFILL_SIGNATURE =
"(ILorg/jibx/runtime/impl/BackFillReference;)V";
private static final String DEFINE_ID_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.defineID";
private static final String DEFINE_ID_SIGNATURE =
"(Ljava/lang/String;ILjava/lang/Object;)V";
protected static final String UNMARSHAL_REQ_ATTRIBUTE =
"org.jibx.runtime.impl.UnmarshallingContext.attributeText";
protected static final String UNMARSHAL_REQ_SIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;";
private static final String UNMARSHAL_TEXT_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.parseContentText";
private static final String UNMARSHAL_TEXT_SIGNATURE =
"()Ljava/lang/String;";
private static final String UNMARSHAL_ELEMENT_TEXT_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.parseElementText";
private static final String UNMARSHAL_ELEMENT_TEXT_SIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;";
private static final String UNMARSHAL_PARSE_IF_START_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.parseIfStartTag";
private static final String UNMARSHAL_PARSE_IF_START_SIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;)Z";
private static final String UNMARSHAL_PARSE_TO_START_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.parseToStartTag";
private static final String UNMARSHAL_PARSE_TO_START_SIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;)V";
private static final String UNMARSHAL_PARSE_PAST_END_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.parsePastEndTag";
private static final String UNMARSHAL_PARSE_PAST_END_SIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;)V";
private static final String UNMARSHAL_SKIPELEMENTMETHOD =
"org.jibx.runtime.impl.UnmarshallingContext.parsePastElement";
private static final String UNMARSHAL_SKIPELEMENTSIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;)V";
private static final String MARSHAL_TEXT_NAME =
"org.jibx.runtime.impl.MarshallingContext.writeContent";
private static final String MARSHAL_CDATA_NAME =
"org.jibx.runtime.impl.MarshallingContext.writeCData";
private static final String MARSHAL_TEXT_SIGNATURE =
"(Ljava/lang/String;)Lorg/jibx/runtime/impl/MarshallingContext;";
private static final String UNMARSHALLING_THROWEXCEPTION_METHOD =
"org.jibx.runtime.impl.UnmarshallingContext.throwException";
private static final String UNMARSHALLING_THROWEXCEPTION_SIGNATURE =
"(Ljava/lang/String;)V";
protected static final String MARSHAL_ATTRIBUTE =
"org.jibx.runtime.impl.MarshallingContext.attribute";
protected static final String MARSHAL_ELEMENT =
"org.jibx.runtime.impl.MarshallingContext.element";
protected static final String MARSHAL_SIGNATURE =
"(ILjava/lang/String;Ljava/lang/String;)" +
"Lorg/jibx/runtime/impl/MarshallingContext;";
protected static final String MARSHAL_STARTTAG_ATTRIBUTES =
"org.jibx.runtime.impl.MarshallingContext.startTagAttributes";
protected static final String MARSHAL_STARTTAG_SIGNATURE =
"(ILjava/lang/String;)Lorg/jibx/runtime/impl/MarshallingContext;";
protected static final String MARSHAL_CLOSESTART_EMPTY =
"org.jibx.runtime.impl.MarshallingContext.closeStartEmpty";
protected static final String MARSHAL_CLOSESTART_EMPTY_SIGNATURE =
"()Lorg/jibx/runtime/impl/MarshallingContext;";
protected static final String UNMARSHAL_ATTRIBUTE_BOOLEAN_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.attributeBoolean";
protected static final String UNMARSHAL_ATTRIBUTE_BOOLEAN_SIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;Z)Z";
//
// Actual instance data
/** Containing binding definition structure. */
private final IContainer m_container;
/** Containing object context. */
private final IContextObj m_objContext;
/** Value style code. */
private final int m_valueStyle;
/** Constant value. */
private final String m_constantValue;
/** Ident type code. */
private final int m_identType;
/** Attribute or element name information. */
private final NameDefinition m_name;
/** Fully qualified name of type. */
private final String m_type;
/** Nillable element flag. */
private final boolean m_isNillable;
/** Linked property information. */
private final PropertyDefinition m_property;
/** Conversion handling for value. */
private final StringConversion m_conversion;
/** Mapping definition for object class supplying identifier. */
private IMapping m_idRefMap;
/**
* Constructor. Saves the context information for later use.
*
* @param contain containing binding definition structure
* @param objc containing object context
* @param name element or attribute name information (may be
* null)
* @param prop property reference information
* @param conv string conversion handler
* @param style value style code
* @param ident identifier type code
* @param constant value for constant
* @param nillable nillable element flag
*/
public ValueChild(IContainer contain, IContextObj objc, NameDefinition name,
PropertyDefinition prop, StringConversion conv, int style, int ident,
String constant, boolean nillable) {
m_container = contain;
m_objContext = objc;
m_name = name;
m_property = prop;
m_type = prop.getTypeName();
m_conversion = conv;
m_valueStyle = style;
m_identType = ident;
m_constantValue = constant;
m_isNillable = nillable;
}
/**
* Create backfill handler class if it does not already exist. This either
* looks up the existing backfill handler class or creates a new one
* specifically for this value.
*
* @return backfill handler class for value
* @throws JiBXException if error in configuration
*/
private ClassFile createBackfillClass() throws JiBXException {
// create the new class
BoundClass bc = m_objContext.getBoundClass();
BindingDefinition def = m_container.getBindingRoot();
String name = bc.getClassFile().deriveClassName(def.getPrefix(),
BACKFILL_SUFFIX + m_property.getName());
ClassFile base = ClassCache.requireClassFile("java.lang.Object");
ClassFile cf = new ClassFile(name, bc.getClassFile().getRoot(),
base, Constants.ACC_PUBLIC, BACKFILL_INTERFACES);
// add member variable for bound class reference
String type = bc.getClassFile().getName();
ClassItem ref = cf.addPrivateField(type, BOUNDREF_NAME);
// add the constructor taking bound class reference
Type[] args = new Type[] { ClassItem.typeFromName(type) };
MethodBuilder mb = new ExceptionMethodBuilder("",
Type.VOID, args, cf, (short)0);
// call the superclass constructor
mb.appendLoadLocal(0);
mb.appendCallInit("java.lang.Object", "()V");
// store bound class reference to member variable
mb.appendLoadLocal(0);
mb.appendLoadLocal(1);
mb.appendPutField(ref);
mb.appendReturn();
mb.codeComplete(false);
mb.addMethod();
// add actual backfill interface implementation method
mb = new ExceptionMethodBuilder(BACKFILL_METHODNAME, Type.VOID,
BACKFILL_METHODARGS, cf, Constants.ACC_PUBLIC);
mb.appendLoadLocal(0);
mb.appendGetField(ref);
mb.appendLoadLocal(1);
mb.appendCreateCast(m_property.getSetValueType());
m_property.genStore(mb);
mb.appendReturn();
mb.codeComplete(false);
mb.addMethod();
// return unique instance of class
return MungedClass.getUniqueSupportClass(cf);
}
/**
* Generate unmarshalling code for object identifier reference. The code
* generated by this method assumes the unmarshalling context and name have
* already been loaded to the stack, and these are consumed by the code.
*
* @param mb method builder
* @throws JiBXException if error in configuration
*/
private void genParseIdRef(ContextMethodBuilder mb) throws JiBXException {
// first part of generated instruction sequence is to check if optional
// value is present
BranchWrapper ifmiss = null;
if (m_property.isOptional()) {
// use existing context reference and name information to check for
// attribute or element present
String name = m_valueStyle == ValueChild.ATTRIBUTE_STYLE ?
CHECK_ATTRIBUTE_NAME : CHECK_ELEMENT_NAME;
mb.appendCallVirtual(name, CHECK_SIGNATURE);
BranchWrapper ifpres = mb.appendIFNE(this);
// push a null value to be stored as result for missing case
mb.appendACONST_NULL();
ifmiss = mb.appendUnconditionalBranch(this);
// reload context reference and name information for use by actual
// unmarshalling call
mb.targetNext(ifpres);
mb.loadContext();
m_name.genPushUriPair(mb);
}
// find index of target class ID map
int index = m_container.getBindingRoot().
getIdClassIndex(m_property.getTypeName());
// check if forward references allowed
if (m_container.getBindingRoot().isForwards()) {
// generate call to unmarshal with forward allowed
mb.appendLoadConstant(index);
String name = m_valueStyle == ValueChild.ATTRIBUTE_STYLE ?
UNMARSHAL_FWDREF_ATTR_NAME : UNMARSHAL_FWDREF_ELEM_NAME;
mb.appendCallVirtual(name, UNMARSHAL_DEFREF_SIGNATURE);
// check for null result returned
mb.appendDUP();
BranchWrapper ifdef = mb.appendIFNONNULL(this);
// build and register backfill handler; start by loading the
// unmarshalling context, then load the index number of the target
// class and create an instance of the backfill handler
ClassFile backclas = createBackfillClass();
mb.loadContext();
mb.appendLoadConstant(index);
mb.appendCreateNew(backclas.getName());
// duplicate the backfill handler reference, then load a reference
// to the owning object and call the initializer before calling
// the unmarshalling context to register the handler
mb.appendDUP();
mb.loadObject();
mb.appendCallInit(backclas.getName(), "(" +
m_objContext.getBoundClass().getClassFile().getSignature() +
")V");
mb.appendCallVirtual(REGISTER_BACKFILL_NAME,
REGISTER_BACKFILL_SIGNATURE);
// set branch target for case where already defined
mb.targetNext(ifdef);
} else {
// generate call to unmarshal with predefined ID required
mb.appendLoadConstant(index);
String name = m_valueStyle == ValueChild.ATTRIBUTE_STYLE ?
UNMARSHAL_DEFREF_ATTR_NAME : UNMARSHAL_DEFREF_ELEM_NAME;
mb.appendCallVirtual(name, UNMARSHAL_DEFREF_SIGNATURE);
}
// handle object type conversion if needed
mb.appendCreateCast(m_property.getSetValueType());
// store returned reference to property
if (ifmiss != null) {
mb.targetNext(ifmiss);
}
m_property.genStore(mb);
}
/**
* Generate test if present code. This generates code that tests if the
* child is present, leaving the result of the test (zero if missing,
* nonzero if present) on the stack.
*
* @param mb unmarshal method builder
* @throws JiBXException if configuration error
*/
public void genIfPresentTest(UnmarshalBuilder mb) throws JiBXException {
// make sure this is an appropriate call
if (m_name == null) {
throw new JiBXException("Method call on invalid value");
}
// load the unmarshalling context and name information, then call the
// appropriate method to test for item present
mb.loadContext();
m_name.genPushUriPair(mb);
String name = (m_valueStyle == ValueChild.ATTRIBUTE_STYLE) ?
CHECK_ATTRIBUTE_NAME : CHECK_ELEMENT_NAME;
mb.appendCallVirtual(name, CHECK_SIGNATURE);
}
/**
* Generate unmarshalling code. This internal method generates the
* necessary code for handling the unmarshalling operation. The code
* generated by this method restores the stack to the original state
* when done.
*
* @param mb method builder
* @throws JiBXException if error in configuration
*/
private void genUnmarshal(ContextMethodBuilder mb) throws JiBXException {
// first part of generated instruction sequence is to preload object
// reference for later use, then load the unmarshalling context and
// the name information
if (m_constantValue == null && !m_property.isImplicit()) {
mb.loadObject();
}
// prepare for parsing the element or attribute name
mb.loadContext();
if (m_name != null) {
m_name.genPushUriPair(mb);
}
// handle flag property
boolean isatt = (m_valueStyle == ValueChild.ATTRIBUTE_STYLE);
if (m_property.hasFlag()) {
if (m_property.isOptional()) {
// generate check for value present in document
if (isatt) {
mb.appendCallVirtual(CHECK_ATTRIBUTE_NAME, CHECK_SIGNATURE);
} else {
// save copy of test result in case of element, to check
// for skip needed
mb.appendCallVirtual(CHECK_ELEMENT_NAME, CHECK_SIGNATURE);
if (m_property.isFlagOnly()) {
mb.appendDUP_X1();
}
}
} else {
// required value, just make sure it's present and set 'true'
if (isatt) {
mb.appendCallVirtual(UNMARSHAL_REQ_ATTRIBUTE,
UNMARSHAL_REQ_SIGNATURE);
mb.appendPOP();
} else {
mb.appendCallVirtual(UNMARSHAL_PARSE_TO_START_NAME,
UNMARSHAL_PARSE_TO_START_SIGNATURE);
}
mb.appendICONST_1();
}
// store the presence flag value
m_property.genFlag(mb);
if (m_property.isFlagOnly()) {
// content ignored, so just skip past element if present
if (!isatt) {
BranchWrapper miss = mb.appendIFEQ(this);
mb.loadContext();
m_name.genPushUriPair(mb);
mb.appendCallVirtual(UNMARSHAL_SKIPELEMENTMETHOD,
UNMARSHAL_SKIPELEMENTSIGNATURE);
mb.appendPOP();
mb.targetNext(miss);
}
return;
} else {
// again prepare for parsing the element or attribute name and
// then storing the value
if (m_constantValue == null && !m_property.isImplicit()) {
mb.loadObject();
}
mb.loadContext();
if (m_name != null) {
m_name.genPushUriPair(mb);
}
}
}
// check if this is an identifier for object
if (m_identType == DEF_IDENT || m_identType == AUTO_IDENT) {
// always unmarshal identifier value as text, then duplicate for use
// if storing
BindingDefinition.s_stringConversion.genParseRequired(isatt, mb);
if (m_identType != AUTO_IDENT) {
mb.appendDUP();
}
// load the context and swap to reorder, load the index for the
// class, and finally the ID'ed object, then call ID definition
// method
mb.loadContext();
mb.appendSWAP();
int index = m_container.getBindingRoot().
getIdClassIndex(m_property.getTypeName());
mb.appendLoadConstant(index);
mb.loadObject();
mb.appendCallVirtual(DEFINE_ID_NAME, DEFINE_ID_SIGNATURE);
// convert from text and store result using object reference loaded
// earlier
if (m_identType != AUTO_IDENT) {
m_conversion.genFromText(mb);
m_property.genStore(mb);
}
} else if (m_identType == REF_IDENT) {
// generate code for unmarshalling object ID
genParseIdRef(mb);
} else if (m_constantValue == null) {
// unmarshal and convert value
if (m_isNillable) {
// first check for element present at all
BranchWrapper ifmiss = null;
if (m_property.isOptional()) {
mb.appendCallVirtual(CHECK_ELEMENT_NAME, CHECK_SIGNATURE);
ifmiss = mb.appendIFEQ(this);
} else {
mb.appendCallVirtual(UNMARSHAL_PARSE_TO_START_NAME,
UNMARSHAL_PARSE_TO_START_SIGNATURE);
}
// check for xsi:nil="true"
mb.loadContext();
mb.appendLoadConstant("http://www.w3.org/2001/XMLSchema-instance");
mb.appendLoadConstant("nil");
mb.appendICONST_0();
mb.appendCallVirtual(UNMARSHAL_ATTRIBUTE_BOOLEAN_NAME,
UNMARSHAL_ATTRIBUTE_BOOLEAN_SIGNATURE);
BranchWrapper notnil = mb.appendIFEQ(this);
// code to handle nil case just parses past end
mb.loadContext();
m_name.genPushUriPair(mb);
mb.appendCallVirtual(UNMARSHAL_PARSE_PAST_END_NAME,
UNMARSHAL_PARSE_PAST_END_SIGNATURE);
// merge path with element not present, which just loads null
mb.targetNext(ifmiss);
mb.appendACONST_NULL();
m_conversion.genFromText(mb);
BranchWrapper ifnil = mb.appendUnconditionalBranch(this);
// read element text and process for not-nil case
mb.targetNext(notnil);
mb.loadContext();
m_name.genPushUriPair(mb);
mb.appendCallVirtual(UNMARSHAL_ELEMENT_TEXT_NAME,
UNMARSHAL_ELEMENT_TEXT_SIGNATURE);
m_conversion.genFromText(mb);
mb.targetNext(ifnil);
} else if (m_valueStyle == ValueChild.TEXT_STYLE ||
m_valueStyle == ValueChild.CDATA_STYLE) {
// unmarshal text value directly and let handler convert
mb.appendCallVirtual(UNMARSHAL_TEXT_NAME,
UNMARSHAL_TEXT_SIGNATURE);
m_conversion.genFromText(mb);
} else if (m_property.isOptional() &&
(isatt || m_container.isContentOrdered())) {
// parse value with possible default in ordered container
m_conversion.genParseOptional(isatt, mb);
} else {
// parse required value, or value in unordered container
m_conversion.genParseRequired(isatt, mb);
}
// handle object type conversion if needed
if (!m_conversion.isPrimitive() && m_property != null) {
String stype = m_conversion.getTypeName();
String dtype = m_property.getSetValueType();
mb.appendCreateCast(stype, dtype);
}
// store result using object reference loaded earlier
m_property.genStore(mb);
} else {
// unmarshal and compare value
BranchWrapper ifmiss = null;
if (m_valueStyle == ValueChild.TEXT_STYLE ||
m_valueStyle == ValueChild.CDATA_STYLE) {
// unmarshal text value directly and let handler convert
mb.appendCallVirtual(UNMARSHAL_TEXT_NAME,
UNMARSHAL_TEXT_SIGNATURE);
} else if (m_property.isOptional() &&
(isatt || m_container.isContentOrdered())) {
// parse optional attribute or element value
m_conversion.genParseOptional(isatt, mb);
mb.appendDUP();
ifmiss = mb.appendIFNULL(this);
} else {
// parse required attribute or element value
m_conversion.genParseRequired(isatt, mb);
}
// compare unmarshalled value with required constant
mb.appendDUP();
mb.appendLoadConstant(m_constantValue);
mb.appendCallVirtual("java.lang.String.equals",
"(Ljava/lang/Object;)Z");
BranchWrapper ifmatch = mb.appendIFNE(this);
// throw exception on comparison error
mb.appendCreateNew("java.lang.StringBuffer");
mb.appendDUP();
mb.appendLoadConstant("Expected constant value \"" +
m_constantValue + "\", found \"");
mb.appendCallInit("java.lang.StringBuffer",
"(Ljava/lang/String;)V");
mb.appendSWAP();
mb.appendCallVirtual("java.lang.StringBuffer.append",
"(Ljava/lang/String;)Ljava/lang/StringBuffer;");
mb.appendLoadConstant("\"");
mb.appendCallVirtual("java.lang.StringBuffer.append",
"(Ljava/lang/String;)Ljava/lang/StringBuffer;");
mb.appendCallVirtual("java.lang.StringBuffer.toString",
"()Ljava/lang/String;");
mb.loadContext();
mb.appendSWAP();
mb.appendCallVirtual(UNMARSHALLING_THROWEXCEPTION_METHOD,
UNMARSHALLING_THROWEXCEPTION_SIGNATURE);
mb.appendACONST_NULL();
// finish by setting target for branch
mb.targetNext(ifmatch);
mb.targetNext(ifmiss);
mb.appendPOP();
}
}
/**
* Generate marshalling code. This internal method generates the
* necessary code for handling the marshalling operation. The code
* generated by this method restores the stack to the original state
* when done.
*
* @param mb method builder
* @throws JiBXException if error in configuration
*/
private void genMarshal(ContextMethodBuilder mb) throws JiBXException {
if (m_constantValue == null) {
// first part of generated instruction sequence is to generate a
// check for an optional property present, then load the context
// and the name information (if present) for later use, then
// finally load the actual property value
BranchWrapper ifmiss = null;
String type = m_property.getTypeName();
if (m_property.hasTest()) {
mb.loadObject();
ifmiss = m_property.genTest(mb);
} else if (m_isNillable && !ClassItem.isPrimitive(type)) {
// check for null object
BranchWrapper ifhit;
if (m_property.isImplicit()) {
mb.appendDUP();
ifhit = mb.appendIFNONNULL(this);
mb.appendPOP();
} else {
mb.loadObject();
m_property.genLoad(mb);
ifhit = mb.appendIFNONNULL(this);
}
// generate empty element with xsi:nil="true"
mb.loadContext();
m_name.genPushIndexPair(mb);
mb.appendCallVirtual(MARSHAL_STARTTAG_ATTRIBUTES,
MARSHAL_STARTTAG_SIGNATURE);
mb.appendLoadConstant(2);
mb.appendLoadConstant("nil");
mb.appendLoadConstant("true");
mb.appendCallVirtual(MARSHAL_ATTRIBUTE, MARSHAL_SIGNATURE);
mb.appendCallVirtual(MARSHAL_CLOSESTART_EMPTY,
MARSHAL_CLOSESTART_EMPTY_SIGNATURE);
mb.appendPOP();
ifmiss = mb.appendUnconditionalBranch(this);
mb.targetNext(ifhit);
}
if (m_name != null) {
// handle implicit property by first saving value to local, then
// reloading after the name information is on the stack
Type tobj = ClassItem.typeFromName(type);
if (m_property.isImplicit()) {
mb.defineSlot(this, tobj);
}
m_name.genPushIndexPair(mb);
if (m_property.isImplicit()) {
mb.appendLoadLocal(mb.getSlot(this));
mb.freeSlot(this);
}
}
if (!m_property.isImplicit()) {
if (m_property.isFlagOnly()) {
mb.appendLoadConstant("");
} else {
mb.loadObject();
m_property.genLoad(mb);
}
}
// check for object identity definition (accessed through property)
StringConversion convert = m_conversion;
if (m_identType == REF_IDENT) {
m_idRefMap.getImplComponent().genLoadId(mb);
convert = BindingDefinition.s_stringConversion;
type = "java.lang.String";
}
// convert to expected type if object
if (!ClassItem.isPrimitive(type)) {
mb.appendCreateCast(type);
}
// convert and marshal value
boolean isatt = m_valueStyle == ValueChild.ATTRIBUTE_STYLE;
if (m_valueStyle == ValueChild.TEXT_STYLE ||
m_valueStyle == ValueChild.CDATA_STYLE) {
convert.genToText(type, mb);
String name = (m_valueStyle == ValueChild.TEXT_STYLE) ?
MARSHAL_TEXT_NAME : MARSHAL_CDATA_NAME;
mb.appendCallVirtual(name, MARSHAL_TEXT_SIGNATURE);
} else if (m_property.isOptional()) {
convert.genWriteOptional(isatt, type, mb);
} else {
convert.genWriteRequired(isatt, type, mb);
}
// finish by setting target for missing optional property test
mb.targetNext(ifmiss);
} else {
// just write constant value directly
if (m_name != null) {
m_name.genPushIndexPair(mb);
}
mb.appendLoadConstant(m_constantValue);
switch (m_valueStyle) {
case ATTRIBUTE_STYLE:
mb.appendCallVirtual(MARSHAL_ATTRIBUTE, MARSHAL_SIGNATURE);
break;
case ELEMENT_STYLE:
mb.appendCallVirtual(MARSHAL_ELEMENT, MARSHAL_SIGNATURE);
break;
case TEXT_STYLE:
mb.appendCallVirtual(MARSHAL_TEXT_NAME,
MARSHAL_TEXT_SIGNATURE);
break;
case CDATA_STYLE:
mb.appendCallVirtual(MARSHAL_CDATA_NAME,
MARSHAL_TEXT_SIGNATURE);
break;
}
}
}
/**
* Get property name. If the child has an associated property this returns
* the name of that property.
*
* @return name for child property
*/
public String getPropertyName() {
if (m_property == null) {
return null;
} else {
return m_property.getName();
}
}
/**
* Check if implicit.
*
* @return true if implicit, false if not
*/
public boolean isImplicit() {
return m_property.isThis();
}
/**
* Switch property from "this" to "implicit".
*/
public void switchProperty() {
m_property.switchProperty();
}
//
// IComponent interface method definitions
public boolean isOptional() {
return m_property.isOptional();
}
public boolean hasAttribute() {
return m_valueStyle == ATTRIBUTE_STYLE;
}
public void genAttrPresentTest(ContextMethodBuilder mb)
throws JiBXException {
// make sure this is an appropriate call
if (m_valueStyle != ATTRIBUTE_STYLE || m_name == null) {
throw new JiBXException("Method call on invalid structure");
}
// generate load of the unmarshalling context and the name information,
// then just call the attribute check method
mb.loadContext();
m_name.genPushUriPair(mb);
mb.appendCallVirtual(CHECK_ATTRIBUTE_NAME, CHECK_SIGNATURE);
}
public void genAttributeUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_valueStyle == ATTRIBUTE_STYLE) {
genUnmarshal(mb);
}
}
public void genAttributeMarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_valueStyle == ATTRIBUTE_STYLE) {
genMarshal(mb);
}
}
public boolean hasContent() {
return m_valueStyle != ATTRIBUTE_STYLE;
}
public void genContentPresentTest(ContextMethodBuilder mb)
throws JiBXException {
// make sure this is an appropriate call
if (m_valueStyle == ELEMENT_STYLE) {
// generate load of the unmarshalling context and the name
// information, then just call the attribute check method
mb.loadContext();
m_name.genPushUriPair(mb);
mb.appendCallVirtual(CHECK_ELEMENT_NAME, CHECK_SIGNATURE);
} else if (m_valueStyle == ATTRIBUTE_STYLE) {
throw new JiBXException("Method call on invalid structure");
} else {
// handle text content by always returned true
mb.appendICONST_1();
}
}
public void genContentUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_valueStyle != ATTRIBUTE_STYLE) {
genUnmarshal(mb);
}
}
public void genContentMarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_valueStyle != ATTRIBUTE_STYLE) {
genMarshal(mb);
}
}
public void genNewInstance(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no instance creation");
}
public String getType() {
return m_type;
}
public boolean hasId() {
return m_identType == DEF_IDENT;
}
public void genLoadId(ContextMethodBuilder mub) throws JiBXException {
m_property.genLoad(mub);
}
public NameDefinition getWrapperName() {
return (m_valueStyle == ELEMENT_STYLE) ? m_name : null;
}
public void setLinkages() throws JiBXException {
if (m_identType == REF_IDENT) {
String type;
if (m_property == null) {
type = m_objContext.getBoundClass().getClassFile().getName();
} else {
type = m_property.getTypeName();
}
m_idRefMap = m_container.getDefinitionContext().
getClassMapping(type);
if (m_idRefMap == null) {
throw new JiBXException("No mapping defined for " +
type + " used as IDREF target");
}
}
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
if (m_valueStyle == ELEMENT_STYLE) {
if (m_isNillable) {
System.out.print("nillable ");
}
System.out.print("element");
} else if (m_valueStyle == ATTRIBUTE_STYLE) {
System.out.print("attribute");
} else if (m_valueStyle == TEXT_STYLE) {
System.out.print("text");
} else if (m_valueStyle == CDATA_STYLE) {
System.out.print("cdata");
}
if (m_name != null) {
System.out.print(" " + m_name.toString());
}
if (m_property != null) {
System.out.print(" from " + m_property.toString());
}
System.out.println();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/ObjectBinding.java 0000644 0001750 0001750 00000140603 11175704114 025370 0 ustar twerner twerner /*
Copyright (c) 2003-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.apache.bcel.Constants;
import org.apache.bcel.generic.ObjectType;
import org.apache.bcel.generic.Type;
import org.jibx.binding.classes.BoundClass;
import org.jibx.binding.classes.BranchWrapper;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.ClassItem;
import org.jibx.binding.classes.ContextMethodBuilder;
import org.jibx.binding.classes.ExceptionMethodBuilder;
import org.jibx.binding.classes.MarshalBuilder;
import org.jibx.binding.classes.MethodBuilder;
import org.jibx.binding.classes.UnmarshalBuilder;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.Utility;
/**
* Binding modifiers that apply to a class reference. This adds the methods used
* for handling binding operations to the object class (or a helper class), then
* generates calls to the added methods as this binding definition is used.
*
* @author Dennis M. Sosnoski
*/
public class ObjectBinding extends PassThroughComponent
implements IComponent, IContextObj
{
//
// Constants and such related to code generation.
// recognized marshal hook method (pre-get) signatures.
private static final String[] MARSHAL_HOOK_SIGNATURES =
{
"(Lorg/jibx/runtime/IMarshallingContext;)V",
"(Ljava/lang/Object;)V",
"()V"
};
// recognized factory hook method signatures.
private static final String[] FACTORY_HOOK_SIGNATURES =
{
"(Lorg/jibx/runtime/IUnmarshallingContext;)",
"(Ljava/lang/Object;)",
"()"
};
// recognized unmarshal hook method (pre-set, post-set) signatures.
private static final String[] UNMARSHAL_HOOK_SIGNATURES =
{
"(Lorg/jibx/runtime/IUnmarshallingContext;)V",
"(Ljava/lang/Object;)V",
"()V"
};
// definitions used in generating calls to user defined methods
private static final String UNMARSHAL_GETSTACKTOPMETHOD =
"org.jibx.runtime.impl.UnmarshallingContext.getStackTop";
private static final String MARSHAL_GETSTACKTOPMETHOD =
"org.jibx.runtime.impl.MarshallingContext.getStackTop";
private static final String GETSTACKTOP_SIGNATURE =
"()Ljava/lang/Object;";
private static final String MARSHALLING_CONTEXT =
"org.jibx.runtime.impl.MarshallingContext";
private static final String UNMARSHALLING_CONTEXT =
"org.jibx.runtime.impl.UnmarshallingContext";
private static final String UNMARSHAL_PARAMETER_SIGNATURE =
"(Lorg/jibx/runtime/impl/UnmarshallingContext;)";
private static final String UNMARSHAL_PUSHOBJECTMETHOD =
"org.jibx.runtime.impl.UnmarshallingContext.pushObject";
private static final String UNMARSHAL_PUSHTRACKEDOBJECTMETHOD =
"org.jibx.runtime.impl.UnmarshallingContext.pushTrackedObject";
private static final String MARSHAL_PUSHOBJECTMETHOD =
"org.jibx.runtime.impl.MarshallingContext.pushObject";
private static final String PUSHOBJECT_SIGNATURE =
"(Ljava/lang/Object;)V";
private static final String UNMARSHAL_POPOBJECTMETHOD =
"org.jibx.runtime.impl.UnmarshallingContext.popObject";
private static final String MARSHAL_POPOBJECTMETHOD =
"org.jibx.runtime.impl.MarshallingContext.popObject";
private static final String POPOBJECT_SIGNATURE = "()V";
private static final String UNMARSHAL_PARAMETER_NORET_SIGNATURE =
"(Lorg/jibx/runtime/impl/UnmarshallingContext;)V";
private static final String MARSHAL_PARAMETER_NORET_SIGNATURE =
"(Lorg/jibx/runtime/impl/MarshallingContext;)V";
// definitions for methods added to mapped class
private static final String NEWINSTANCE_SUFFIX = "_newinstance";
private static final String PREPARE_SUFFIX = "_prepare";
private static final String COMPLETE_SUFFIX = "_complete";
private static final String ATTR_PRESENCE_SUFFIX = "_attrTest";
private static final String UNMARSHAL_ATTR_SUFFIX = "_unmarshalAttr";
private static final String MARSHAL_ATTR_SUFFIX = "_marshalAttr";
private static final String PRESENCE_SUFFIX = "_test";
private static final String UNMARSHAL_SUFFIX = "_unmarshal";
private static final String MARSHAL_SUFFIX = "_marshal";
private static final Type UNMARSHALCONTEXT_TYPE =
new ObjectType(UNMARSHALLING_CONTEXT);
private static final Type[] UNMARSHALCONTEXT_ARGS =
{
UNMARSHALCONTEXT_TYPE
};
private static final Type MARSHALCONTEXT_TYPE =
new ObjectType(MARSHALLING_CONTEXT);
// definitions for source position tracking
private static final String SOURCE_TRACKING_INTERFACE =
"org.jibx.runtime.impl.ITrackSourceImpl";
private static final String SETSOURCE_METHODNAME = "jibx_setSource";
private static final Type[] SETSOURCE_ARGS =
{
Type.STRING, Type.INT, Type.INT
};
private static final String SOURCEDOCUMENT_FIELDNAME ="jibx_sourceDocument";
private static final String SOURCELINE_FIELDNAME = "jibx_sourceLine";
private static final String SOURCECOLUMN_FIELDNAME = "jibx_sourceColumn";
private static final String SOURCENAME_METHODNAME = "jibx_getDocumentName";
private static final String SOURCELINE_METHODNAME = "jibx_getLineNumber";
private static final String SOURCECOLUMN_METHODNAME =
"jibx_getColumnNumber";
private static final Type[] EMPTY_ARGS = {};
//
// Actual instance data.
/** Containing binding definition structure. */
private final IContainer m_container;
/** Class linked to mapping. */
private BoundClass m_class;
/** Object factory method. */
private final ClassItem m_factoryMethod;
/** Preset method for object. */
private final ClassItem m_preSetMethod;
/** Postset method for object. */
private final ClassItem m_postSetMethod;
/** Preget method for object. */
private final ClassItem m_preGetMethod;
/** Type to be used for creating new instances. */
private final ClassFile m_createClass;
/** Create method fully-qualified name (null if not yet
generated). */
private String m_createName;
/** Checked for complete method needed flag. */
private boolean m_checkedComplete;
/** Checked for prepare method needed flag. */
private boolean m_checkedPrepare;
/** Complete method name (null if none, or not yet checked). */
private String m_completeName;
/** Prepare method name (null if none, or not yet checked). */
private String m_prepareName;
/** Generated new instance method. */
private ClassItem m_newInstanceMethod;
/** Flag for recursion while generating attribute presence test. */
private boolean m_lockAttributePresence;
/** Flag for recursion while generating content presence test. */
private boolean m_lockContentPresence;
/** Flag for recursion while generating attribute unmarshal. */
private boolean m_lockAttributeUnmarshal;
/** Flag for recursion while generating attribute marshal. */
private boolean m_lockAttributeMarshal;
/** Flag for recursion while generating attribute unmarshal. */
private boolean m_lockContentUnmarshal;
/** Flag for recursion while generating attribute marshal. */
private boolean m_lockContentMarshal;
/** Name for attribute presence test method (null unless
generation started). */
private String m_attributePresenceName;
/** Name for content presence test method (null unless
generation started). */
private String m_contentPresenceName;
/** Signature used for unmarshal methods. */
private String m_unmarshalSignature;
/** Name for unmarshal attribute method (null unless
generation started). */
private String m_unmarshalAttributeName;
/** Name for unmarshal content method (null unless
generation started). */
private String m_unmarshalContentName;
/** Signature used for marshal methods. */
private String m_marshalSignature;
/** Name for marshal attribute method (null unless
generation started). */
private String m_marshalAttributeName;
/** Name for marshal content method (null unless
generation started). */
private String m_marshalContentName;
/** Generated attribute presence test method. */
private ClassItem m_attributePresenceMethod;
/** Generated content presence test method. */
private ClassItem m_contentPresenceMethod;
/** Generated unmarshal attribute method. */
private ClassItem m_unmarshalAttributeMethod;
/** Generated unmarshal content method. */
private ClassItem m_unmarshalContentMethod;
/** Generated marshal attribute method. */
private ClassItem m_marshalAttributeMethod;
/** Generated marshal content method. */
private ClassItem m_marshalContentMethod;
/** Child supplying instance identifier value. */
private IComponent m_idChild;
/** Fake content present flag, used when neither content nor attributes
are present. */
private boolean m_fakeContent;
/** Flag for dummy object binding, used when a concrete mapping just adds a
name around an abstract mapping. */
private boolean m_mappingWrapper;
/**
* Constructor. This initializes the definition context to be the same as
* the parent's. Subclasses may change this definition context if
* appropriate.
*
* @param contain containing binding definition component
* @param objc current object context
* @param type fully qualified class name for bound object
* @param fact user new instance factory method
* @param pres user preset method for unmarshalling
* @param posts user postset method for unmarshalling
* @param pget user preget method for marshalling
* @param ctype type to use for creating new instance (null if
* not specified)
* @throws JiBXException if method not found
*/
public ObjectBinding(IContainer contain, IContextObj objc, String type,
String fact, String pres, String posts, String pget, String ctype)
throws JiBXException {
// initialize the basics
m_container = contain;
BoundClass ctxc = (objc == null) ? null : objc.getBoundClass();
m_class = BoundClass.getInstance(type, ctxc);
ClassFile cf = m_class.getClassFile();
if (ctype == null) {
m_createClass = cf;
} else {
m_createClass = ClassCache.requireClassFile(ctype);
}
// check instance creation for unmarshalling
if (fact == null) {
m_factoryMethod = null;
} else {
// look up supplied static factory method
int split = fact.lastIndexOf('.');
if (split >= 0) {
// verify the method is defined
String cname = fact.substring(0, split);
String mname = fact.substring(split+1);
ClassFile mcf = ClassCache.requireClassFile(cname);
m_factoryMethod = mcf.getMethod(mname,
FACTORY_HOOK_SIGNATURES);
if (m_factoryMethod == null) {
throw new JiBXException("Factory method " + fact +
" not found");
} else {
// force access if necessary
m_factoryMethod.makeAccessible(cf);
}
} else {
m_factoryMethod = null;
}
if (m_factoryMethod == null) {
throw new JiBXException("Factory method " + fact +
" not found.");
}
}
// look up other method names as members of class
if (pres == null) {
m_preSetMethod = null;
} else {
m_preSetMethod = cf.getMethod(pres, UNMARSHAL_HOOK_SIGNATURES);
if (m_preSetMethod == null) {
throw new JiBXException("User method " + pres + " not found.");
}
}
if (posts == null) {
m_postSetMethod = null;
} else {
m_postSetMethod = cf.getMethod(posts, UNMARSHAL_HOOK_SIGNATURES);
if (m_postSetMethod == null) {
throw new JiBXException("User method " + posts + " not found.");
}
}
if (pget == null) {
m_preGetMethod = null;
} else {
m_preGetMethod = cf.getMethod(pget, MARSHAL_HOOK_SIGNATURES);
if (m_preGetMethod == null) {
throw new JiBXException("User method " + pget + " not found.");
}
}
}
/**
* Generate code for calling a user supplied method. The object methods
* support three signature variations, with no parameters, with the
* marshalling or unmarshalling context, or with the owning object.
*
* @param in flag for unmarshalling method
* @param method information for method being called
* @param mb method builder for generated code
*/
private void genUserMethodCall(boolean in, ClassItem method,
ContextMethodBuilder mb) {
// load object reference for virtual call
if (!method.isStatic()) {
mb.loadObject();
}
// check if parameter required for call
if (method.getArgumentCount() > 0) {
// generate code to load context, then get containing object if
// needed for call
mb.loadContext();
String type = method.getArgumentType(0);
if ("java.lang.Object".equals(type)) {
String name = in ? UNMARSHAL_GETSTACKTOPMETHOD :
MARSHAL_GETSTACKTOPMETHOD;
mb.appendCallVirtual(name, GETSTACKTOP_SIGNATURE);
}
}
// generate appropriate form of call to user method
mb.appendCall(method);
mb.addMethodExceptions(method);
}
/**
* Generate create method for object. The generated method matches the
* {@link ITypeBinding#getCreateMethod()} result signature.
*
* @throws JiBXException if error in generating code
*/
private void genCreateMethod() throws JiBXException {
if (m_newInstanceMethod == null && (!m_mappingWrapper ||
m_factoryMethod != null || m_preSetMethod != null)) {
// set up for constructing new method
String name = m_container.getBindingRoot().getPrefix() +
NEWINSTANCE_SUFFIX;
ClassFile cf = m_class.getMungedFile();
Type type = m_class.getClassFile().getType();
ContextMethodBuilder mb = new ContextMethodBuilder(name, type,
new Type[] {type, UNMARSHALCONTEXT_TYPE}, cf,
Constants.ACC_PUBLIC|Constants.ACC_STATIC, 0,
m_class.getClassName(), 1, UNMARSHALLING_CONTEXT);
// check if actually need to create a new instance
mb.loadObject();
BranchWrapper haveinst = mb.appendIFNONNULL(this);
// check for factory supplied to create instance
boolean haveobj = true;
if (m_factoryMethod == null) {
if (m_createClass.isArray()) {
// construct array instance directly with basic size
mb.appendLoadConstant(Utility.MINIMUM_GROWN_ARRAY_SIZE);
String tname = m_createClass.getName();
mb.appendCreateArray(tname.substring(0, tname.length()-2));
} else if (m_createClass.isInterface() ||
m_createClass.isAbstract()) {
// cannot create instance, throw exception
mb.appendCreateNew(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
mb.appendDUP();
mb.appendLoadConstant("Cannot create instance of interface or abstract class " +
m_createClass.getName());
mb.appendCallInit(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS,
MethodBuilder.EXCEPTION_CONSTRUCTOR_SIGNATURE1);
mb.appendThrow();
haveobj = false;
} else {
// check if we have a no argument constructor
ClassItem cons = m_createClass.getInitializerMethod("()V");
if (cons == null) {
if (m_container.getBindingRoot().isAddConstructors()) {
m_createClass.addDefaultConstructor();
} else {
// cannot create instance, throw exception
mb.appendCreateNew(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
mb.appendDUP();
mb.appendLoadConstant("Cannot create instance of class " +
m_createClass.getName() + " (no default constructor)");
mb.appendCallInit(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS,
MethodBuilder.EXCEPTION_CONSTRUCTOR_SIGNATURE1);
mb.appendThrow();
haveobj = false;
}
} else {
cons.makeAccessible(m_class.getMungedFile());
}
if (haveobj) {
// no factory, so create an instance, duplicate the
// reference, and then call the null constructor
mb.appendCreateNew(m_createClass.getName());
mb.appendDUP();
mb.appendCallInit(m_createClass.getName(),"()V");
}
}
} else {
// generate call to factory method
genUserMethodCall(true, m_factoryMethod, mb);
mb.appendCreateCast(m_factoryMethod.getTypeName(),
m_class.getClassName());
}
// save created instance to be returned
if (haveobj) {
mb.storeObject();
}
// if preset method supplied add code to call it
mb.targetNext(haveinst);
// ** disable for now; can't take out of unmarshal methods, since
// create not always called **
// if (m_preSetMethod != null) {
// genUserMethodCall(true, m_preSetMethod, mb);
// }
// finish method code with return of new instance
mb.loadObject();
mb.appendReturn(m_class.getClassName());
m_newInstanceMethod = m_class.getUniqueMethod(mb).getItem();
}
}
/**
* Generate prepare for marshalling method for object, if needed. The
* generated method matches the {@link ITypeBinding#getPrepareMethod()}
* result signature.
*
* @throws JiBXException if error in generating code
*/
private void genPrepareMethod() throws JiBXException {
if (!m_checkedPrepare) {
// ** disable for now; can't take out of marshal methods, since
// prepare not always called **
// if (m_preGetMethod != null &&
// m_container.getBindingRoot().isOutput()) {
//
// // set up for constructing new method
// String name = m_container.getBindingRoot().getPrefix() +
// PREPARE_SUFFIX;
// Type[] args = new Type[2];
// args[0] = m_class.getClassFile().getType();
// args[1] = MARSHALCONTEXT_TYPE;
// ContextMethodBuilder mb = new ContextMethodBuilder(name,
// Type.VOID, args, m_class.getMungedFile(),
// Constants.ACC_PUBLIC | Constants.ACC_STATIC, 0,
// m_class.getClassName(), 1, MARSHALLING_CONTEXT);
//
// // just generate embedded call to user method
// genUserMethodCall(false, m_preGetMethod, mb);
// mb.appendReturn();
//
// // add method to class
// m_prepareName =
// m_class.getUniqueMethod(mb).getItem().getFullName();
//
// }
// flag checked for next time called
m_checkedPrepare = true;
}
}
/**
* Generate unmarshalling complete method for object, if needed. The
* generated method matches the {@link ITypeBinding#getCompleteMethod()}
* result signature.
*
* @throws JiBXException if error in generating code
*/
private void genCompleteMethod() throws JiBXException {
if (!m_checkedComplete) {
// ** disable for now; can't take out of unmarshal methods, since
// complete not always called **
// if (m_postSetMethod != null &&
// m_container.getBindingRoot().isInput()) {
//
// // set up for constructing new method
// String name = m_container.getBindingRoot().getPrefix() +
// COMPLETE_SUFFIX;
// Type[] args = new Type[2];
// args[0] = m_class.getClassFile().getType();
// args[1] = UNMARSHALCONTEXT_TYPE;
// ContextMethodBuilder mb = new ContextMethodBuilder(name,
// Type.VOID, args, m_class.getMungedFile(),
// Constants.ACC_PUBLIC | Constants.ACC_STATIC, 0,
// m_class.getClassName(), 1, UNMARSHALLING_CONTEXT);
//
// // just generate embedded call to user method
// genUserMethodCall(true, m_postSetMethod, mb);
// mb.appendReturn();
//
// // add method to class
// m_completeName =
// m_class.getUniqueMethod(mb).getItem().getFullName();
//
// }
// flag checked for next time called
m_checkedComplete = true;
}
}
/**
* Generate code to handle unmarshal source location tracking. This
* convenience method generates the member variables and method used to
* support setting the source location, the methods used to access the
* information, and also adds the appropriate interfaces to the class.
*/
private void genTrackSourceCode() {
ClassFile cf = m_class.getMungedFile();
if (m_class.isDirectAccess() && !cf.isAbstract() &&
cf.addInterface(SOURCE_TRACKING_INTERFACE)) {
// add position tracking fields to class
ClassItem srcname = cf.addPrivateField("java.lang.String;",
SOURCEDOCUMENT_FIELDNAME);
ClassItem srcline = cf.addPrivateField("int", SOURCELINE_FIELDNAME);
ClassItem srccol = cf.addPrivateField("int",
SOURCECOLUMN_FIELDNAME);
// add method for setting the source information
MethodBuilder mb = new ExceptionMethodBuilder(SETSOURCE_METHODNAME,
Type.VOID, SETSOURCE_ARGS, cf, Constants.ACC_PUBLIC);
mb.appendLoadLocal(0);
mb.appendLoadLocal(1);
mb.appendPutField(srcname);
mb.appendLoadLocal(0);
mb.appendLoadLocal(2);
mb.appendPutField(srcline);
mb.appendLoadLocal(0);
mb.appendLoadLocal(3);
mb.appendPutField(srccol);
mb.appendReturn();
mb.codeComplete(false);
mb.addMethod();
// add methods for getting the source information
mb = new ExceptionMethodBuilder(SOURCENAME_METHODNAME,
Type.STRING, EMPTY_ARGS, cf, Constants.ACC_PUBLIC);
mb.appendLoadLocal(0);
mb.appendGetField(srcname);
mb.appendReturn(Type.STRING);
mb.codeComplete(false);
mb.addMethod();
mb = new ExceptionMethodBuilder(SOURCELINE_METHODNAME,
Type.INT, EMPTY_ARGS, cf, Constants.ACC_PUBLIC);
mb.appendLoadLocal(0);
mb.appendGetField(srcline);
mb.appendReturn("int");
mb.codeComplete(false);
mb.addMethod();
mb = new ExceptionMethodBuilder(SOURCECOLUMN_METHODNAME,
Type.INT, EMPTY_ARGS, cf, Constants.ACC_PUBLIC);
mb.appendLoadLocal(0);
mb.appendGetField(srccol);
mb.appendReturn("int");
mb.codeComplete(false);
mb.addMethod();
}
}
/**
* Generate attribute presence test method for object. The generated method
* matches the {@link ITypeBinding#getAttributePresentTestMethod()} result
* signature.
*
* @throws JiBXException if error in configuration
*/
private void genAttributePresenceMethod() throws JiBXException {
if (m_attributePresenceMethod == null) {
// set up for constructing new method
String name = m_container.getBindingRoot().getPrefix() +
ATTR_PRESENCE_SUFFIX;
ContextMethodBuilder meth = new ContextMethodBuilder(name,
Type.BOOLEAN, UNMARSHALCONTEXT_ARGS, m_class.getMungedFile(),
Constants.ACC_PUBLIC | Constants.ACC_STATIC, -1, null,
0, UNMARSHALLING_CONTEXT);
m_attributePresenceName = meth.getFullName();
// generate the presence test code
m_component.genAttrPresentTest(meth);
meth.appendReturn(Type.BOOLEAN);
// add method to class
if (m_lockAttributePresence) {
m_attributePresenceMethod =
m_class.getUniqueNamed(meth).getItem();
} else {
m_attributePresenceMethod =
m_class.getUniqueMethod(meth).getItem();
m_attributePresenceName =
m_attributePresenceMethod.getFullName();
}
} else {
m_lockAttributePresence = true;
}
}
/**
* Generate attribute unmarshal method for object. The generated method
* matches the {@link ITypeBinding#getAttributeUnmarshalMethod()} result
* signature.
*
* @throws JiBXException if error in configuration
*/
private void genUnmarshalAttributeMethod() throws JiBXException {
if (m_unmarshalAttributeName == null) {
// set up for constructing new method
String name = m_container.getBindingRoot().getPrefix() +
UNMARSHAL_ATTR_SUFFIX;
UnmarshalBuilder meth = new UnmarshalBuilder(name,
m_class.getClassFile(), m_class.getMungedFile());
m_unmarshalAttributeName = meth.getFullName();
m_unmarshalSignature = meth.getSignature();
// if preset method supplied add code to call it
if (m_preSetMethod != null) {
meth.loadObject();
genUserMethodCall(true, m_preSetMethod, meth);
}
// push object being unmarshalled to unmarshaller stack
meth.loadContext();
meth.loadObject();
meth.appendCallVirtual(UNMARSHAL_PUSHTRACKEDOBJECTMETHOD,
PUSHOBJECT_SIGNATURE);
// generate the actual unmarshalling code in method
meth.loadObject();
m_component.genAttributeUnmarshal(meth);
// pop object from unmarshal stack
meth.loadContext();
meth.appendCallVirtual(UNMARSHAL_POPOBJECTMETHOD,
POPOBJECT_SIGNATURE);
// if postset method supplied and no content add code to call it
if (m_postSetMethod != null && !hasContent()) {
genUserMethodCall(true, m_postSetMethod, meth);
}
// finish by returning object
meth.loadObject();
meth.appendReturn(m_class.getClassFile().getName());
// add method to class
if (m_lockAttributeUnmarshal) {
m_unmarshalAttributeMethod =
m_class.getUniqueNamed(meth).getItem();
} else {
m_unmarshalAttributeMethod =
m_class.getUniqueMethod(meth).getItem();
m_unmarshalAttributeName =
m_unmarshalAttributeMethod.getFullName();
}
} else {
m_lockAttributeUnmarshal = true;
}
}
/**
* Generate attribute marshal method for object. The generated method
* matches the {@link ITypeBinding#getAttributeMarshalMethod()} result
* signature.
*
* @throws JiBXException if error in configuration
*/
private void genMarshalAttributeMethod() throws JiBXException {
if (m_marshalAttributeName == null) {
// set up for constructing new method
String name = m_container.getBindingRoot().getPrefix() +
MARSHAL_ATTR_SUFFIX;
MarshalBuilder meth = new MarshalBuilder(name,
m_class.getClassFile(), m_class.getMungedFile());
m_marshalAttributeName = meth.getFullName();
m_marshalSignature = meth.getSignature();
// if preget method supplied add code to call it
if (m_preGetMethod != null) {
genUserMethodCall(false, m_preGetMethod, meth);
}
// push object being marshalled to marshaller stack
meth.loadContext();
meth.loadObject();
meth.appendCallVirtual(MARSHAL_PUSHOBJECTMETHOD,
PUSHOBJECT_SIGNATURE);
// generate actual marshalling code
meth.loadContext();
m_component.genAttributeMarshal(meth);
// pop object from stack
meth.loadContext();
meth.appendCallVirtual(MARSHAL_POPOBJECTMETHOD,
POPOBJECT_SIGNATURE);
// finish and add constructed method to class
meth.appendReturn();
if (m_lockAttributeMarshal) {
m_marshalAttributeMethod =
m_class.getUniqueNamed(meth).getItem();
} else {
m_marshalAttributeMethod =
m_class.getUniqueMethod(meth).getItem();
m_marshalAttributeName =
m_marshalAttributeMethod.getFullName();
}
} else {
m_lockAttributeMarshal = true;
}
}
/**
* Generate content presence test method for object. The generated method
* matches the {@link ITypeBinding#getContentPresentTestMethod()} result
* signature.
*
* @throws JiBXException if error in configuration
*/
private void genContentPresenceMethod() throws JiBXException {
if (m_contentPresenceMethod == null) {
// set up for constructing new method
String name = m_container.getBindingRoot().getPrefix() +
PRESENCE_SUFFIX;
ContextMethodBuilder meth = new ContextMethodBuilder(name,
Type.BOOLEAN, UNMARSHALCONTEXT_ARGS, m_class.getMungedFile(),
Constants.ACC_PUBLIC | Constants.ACC_STATIC, -1, null,
0, UNMARSHALLING_CONTEXT);
m_contentPresenceName = meth.getFullName();
// generate the presence test code
if (m_fakeContent) {
meth.appendLoadConstant(1);
} else {
m_component.genContentPresentTest(meth);
}
meth.appendReturn(Type.BOOLEAN);
// add method to class
if (m_lockContentPresence) {
m_contentPresenceMethod =
m_class.getUniqueNamed(meth).getItem();
} else {
m_contentPresenceMethod =
m_class.getUniqueMethod(meth).getItem();
m_contentPresenceName =
m_contentPresenceMethod.getFullName();
}
} else {
m_lockContentPresence = true;
}
}
/**
* Generate content unmarshal method for object. The generated method
* matches the {@link ITypeBinding#getContentUnmarshalMethod()} result
* signature.
*
* @throws JiBXException
*/
private void genUnmarshalContentMethod() throws JiBXException {
if (m_unmarshalContentName == null) {
// set up for constructing new method
String name = m_container.getBindingRoot().getPrefix() +
UNMARSHAL_SUFFIX;
UnmarshalBuilder meth = new UnmarshalBuilder(name,
m_class.getClassFile(), m_class.getMungedFile());
m_unmarshalContentName = meth.getFullName();
m_unmarshalSignature = meth.getSignature();
// if preset method supplied add code to call it
if (!hasAttribute() && m_preSetMethod != null) {
meth.loadObject();
genUserMethodCall(true, m_preSetMethod, meth);
}
// push object being unmarshalled to unmarshaller stack
meth.loadContext();
meth.loadObject();
String mname = hasAttribute() ? UNMARSHAL_PUSHOBJECTMETHOD :
UNMARSHAL_PUSHTRACKEDOBJECTMETHOD;
meth.appendCallVirtual(mname, PUSHOBJECT_SIGNATURE);
// generate the actual unmarshalling code in method
meth.loadObject();
if (!m_fakeContent) {
m_component.genContentUnmarshal(meth);
}
// pop object from unmarshal stack
meth.loadContext();
meth.appendCallVirtual(UNMARSHAL_POPOBJECTMETHOD,
POPOBJECT_SIGNATURE);
// if postset method supplied and no attributes add code to call
if (m_postSetMethod != null) {
genUserMethodCall(true, m_postSetMethod, meth);
}
// finish by returning object
meth.loadObject();
meth.appendReturn(m_class.getClassFile().getName());
// add method to class
if (m_lockContentUnmarshal) {
m_unmarshalContentMethod =
m_class.getUniqueNamed(meth).getItem();
} else {
m_unmarshalContentMethod =
m_class.getUniqueMethod(meth).getItem();
m_unmarshalContentName =
m_unmarshalContentMethod.getFullName();
}
} else {
m_lockContentUnmarshal = true;
}
}
/**
* Generate content marshal method for object. The generated method
* matches the {@link ITypeBinding#getContentMarshalMethod()} result
* signature.
*
* @throws JiBXException
*/
private void genMarshalContentMethod() throws JiBXException {
if (m_marshalContentName == null) {
// set up for constructing new method
String name =
m_container.getBindingRoot().getPrefix() + MARSHAL_SUFFIX;
MarshalBuilder meth = new MarshalBuilder(name,
m_class.getClassFile(), m_class.getMungedFile());
m_marshalContentName = meth.getFullName();
m_marshalSignature = meth.getSignature();
// if preget method supplied and no attributes add code to call it
if (m_preGetMethod != null && !hasAttribute()) {
genUserMethodCall(false, m_preGetMethod, meth);
}
// push object being marshalled to marshaller stack
meth.loadContext();
meth.loadObject();
meth.appendCallVirtual(MARSHAL_PUSHOBJECTMETHOD,
PUSHOBJECT_SIGNATURE);
// generate actual marshalling code
meth.loadContext();
if (!m_fakeContent) {
m_component.genContentMarshal(meth);
}
// pop object from stack
meth.loadContext();
meth.appendCallVirtual(MARSHAL_POPOBJECTMETHOD,
POPOBJECT_SIGNATURE);
// finish and add constructed method to class
meth.appendReturn();
if (m_lockContentMarshal) {
m_marshalContentMethod =
m_class.getUniqueNamed(meth).getItem();
} else {
m_marshalContentMethod =
m_class.getUniqueMethod(meth).getItem();
m_marshalContentName = m_marshalContentMethod.getFullName();
}
} else {
m_lockContentMarshal = true;
}
}
//
// IContextObj interface method definitions
public BoundClass getBoundClass() {
return m_class;
}
public boolean setIdChild(IComponent child) {
if (m_idChild == null) {
m_idChild = child;
return true;
} else {
return false;
}
}
//
// IComponent interface method definitions
public boolean isOptional() {
return false;
}
public boolean hasContent() {
return m_fakeContent || super.hasContent();
}
public void genAttrPresentTest(ContextMethodBuilder mb)
throws JiBXException {
if (m_mappingWrapper) {
super.genAttrPresentTest(mb);
} else {
// check if attribute presence method needs to be added to class
if (m_attributePresenceMethod == null) {
genAttributePresenceMethod();
}
// generate code to call attribute presence test method
mb.loadContext(UNMARSHALLING_CONTEXT);
mb.appendCall(m_attributePresenceMethod);
}
}
public void genContentPresentTest(ContextMethodBuilder mb)
throws JiBXException {
if (m_mappingWrapper) {
super.genContentPresentTest(mb);
} else {
// check if content presence method needs to be added to class
if (m_contentPresenceMethod == null) {
genContentPresenceMethod();
}
// generate code to call attribute presence test method
mb.loadContext(UNMARSHALLING_CONTEXT);
mb.appendCall(m_contentPresenceMethod);
}
}
public void genAttributeUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_mappingWrapper) {
super.genAttributeUnmarshal(mb);
} else {
// check if unmarshal method needs to be added to class
if (m_unmarshalAttributeMethod == null) {
genUnmarshalAttributeMethod();
}
// generate code to call created unmarshal method
mb.loadContext(UNMARSHALLING_CONTEXT);
mb.appendCallStatic(m_unmarshalAttributeName, m_unmarshalSignature);
}
}
public void genAttributeMarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_mappingWrapper) {
super.genAttributeMarshal(mb);
} else {
// check if marshal method needs to be added to class
if (m_marshalAttributeMethod == null) {
genMarshalAttributeMethod();
}
// generate code to call created marshal method
mb.loadContext(MARSHALLING_CONTEXT);
mb.appendCallStatic(m_marshalAttributeName, m_marshalSignature);
}
}
public void genContentUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_mappingWrapper) {
super.genContentUnmarshal(mb);
} else {
// check if unmarshal method needs to be added to class
if (m_unmarshalContentMethod == null) {
genUnmarshalContentMethod();
}
// generate code to call created unmarshal method
mb.loadContext(UNMARSHALLING_CONTEXT);
mb.appendCallStatic(m_unmarshalContentName, m_unmarshalSignature);
}
}
public void genContentMarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_mappingWrapper) {
super.genContentMarshal(mb);
} else {
// check if marshal method needs to be added to class
if (m_marshalContentMethod == null) {
genMarshalContentMethod();
}
// generate code to call created marshal method
mb.loadContext(MARSHALLING_CONTEXT);
mb.appendCallStatic(m_marshalContentName, m_marshalSignature);
}
}
public void genNewInstance(ContextMethodBuilder mb) throws JiBXException {
genCreateMethod();
if (m_newInstanceMethod == null) {
super.genNewInstance(mb);
} else {
// generate code to call new instance method
mb.loadContext(UNMARSHALLING_CONTEXT);
mb.appendCall(m_newInstanceMethod);
}
}
public String getType() {
return m_class.getClassName();
}
public boolean hasId() {
return m_idChild != null;
}
public void genLoadId(ContextMethodBuilder mb) throws JiBXException {
if (m_idChild == null) {
throw new IllegalStateException("Internal error: no id defined");
} else {
m_idChild.genLoadId(mb);
}
}
public void setLinkages() throws JiBXException {
IComponent comp = m_component;
MappingReference ref = null;
if (comp instanceof NestedStructure) {
NestedStructure struct = (NestedStructure)comp;
if (struct.isMappingReference()) {
ref = (MappingReference)struct.getContents().get(0);
}
}
super.setLinkages();
if (ref == null) {
m_fakeContent = !super.hasAttribute() && !super.hasContent();
} else {
IMapping mapping = ref.getMapping();
if (mapping != null && mapping.getBoundType().equals(getType())) {
IComponent wrapped = ref.m_component;
if (wrapped instanceof BaseMappingWrapper) {
BaseMappingWrapper wrapper = (BaseMappingWrapper)wrapped;
setWrappedComponent(wrapper.m_component);
m_mappingWrapper = true;
}
}
}
if (m_container.getBindingRoot().isTrackSource()) {
genTrackSourceCode();
}
}
//
// ITypeBinding interface method definitions
public String getAttributeMarshalMethod() throws JiBXException {
if (m_container.getBindingRoot().isOutput() && hasAttribute() &&
!m_mappingWrapper) {
if (m_marshalAttributeMethod == null) {
genMarshalAttributeMethod();
}
return m_marshalAttributeName;
} else {
return null;
}
}
public String getAttributePresentTestMethod() throws JiBXException {
if (m_container.getBindingRoot().isInput() && hasAttribute() &&
!m_mappingWrapper) {
if (m_attributePresenceMethod == null) {
genAttributePresenceMethod();
}
return m_attributePresenceName;
} else {
return null;
}
}
public String getAttributeUnmarshalMethod() throws JiBXException {
if (m_container.getBindingRoot().isInput() && hasAttribute() &&
!m_mappingWrapper) {
if (m_unmarshalAttributeMethod == null) {
genUnmarshalAttributeMethod();
}
return m_unmarshalAttributeName;
} else {
return null;
}
}
public String getCompleteMethod() throws JiBXException {
genCompleteMethod();
return m_completeName;
}
public String getContentMarshalMethod() throws JiBXException {
if (m_container.getBindingRoot().isOutput() && hasContent() &&
!m_mappingWrapper) {
if (m_marshalContentMethod == null) {
genMarshalContentMethod();
}
return m_marshalContentName;
} else {
return null;
}
}
public String getContentPresentTestMethod() throws JiBXException {
if (m_container.getBindingRoot().isInput() && hasContent() &&
!m_mappingWrapper) {
if (m_contentPresenceMethod == null) {
genContentPresenceMethod();
}
return m_contentPresenceName;
} else {
return null;
}
}
public String getContentUnmarshalMethod() throws JiBXException {
if (m_container.getBindingRoot().isInput() && hasContent() &&
!m_mappingWrapper) {
if (m_unmarshalContentMethod == null) {
genUnmarshalContentMethod();
}
return m_unmarshalContentName;
} else {
return null;
}
}
public String getCreateMethod() throws JiBXException {
if (m_container.getBindingRoot().isInput() &&
!m_mappingWrapper) {
genCreateMethod();
return m_newInstanceMethod.getFullName();
} else {
return null;
}
}
public String getPrepareMethod() throws JiBXException {
genPrepareMethod();
return m_prepareName;
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.print("object binding for " +
m_class.getClassFile().getName());
if (m_createClass != null) {
System.out.print(" create class " + m_createClass.getName());
}
if (m_factoryMethod != null) {
System.out.print(" factory=" + m_factoryMethod.getName());
}
if (m_preSetMethod != null) {
System.out.print(" preset=" + m_preSetMethod.getName());
}
if (m_postSetMethod != null) {
System.out.print(" postset=" + m_postSetMethod.getName());
}
if (m_preGetMethod != null) {
System.out.print(" preget=" + m_preGetMethod.getName());
}
if (m_mappingWrapper) {
System.out.print(" (mapping wrapper)");
}
System.out.println();
m_component.print(depth+1);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/BaseMappingWrapper.java 0000644 0001750 0001750 00000006067 10524434556 026432 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.jibx.binding.classes.*;
import org.jibx.runtime.JiBXException;
/**
* Component decorator for abstract base mapping from extension mapping. This
* just handles necessary glue code generation.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class BaseMappingWrapper extends PassThroughComponent
{
/**
* Constructor.
*
* @param wrap wrapped binding component
*/
public BaseMappingWrapper(IComponent wrap) {
super(wrap);
}
//
// IComponent interface method definitions
public void genAttributeUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
mb.loadObject();
super.genAttributeUnmarshal(mb);
}
public void genAttributeMarshal(ContextMethodBuilder mb)
throws JiBXException {
mb.loadObject();
super.genAttributeMarshal(mb);
}
public void genContentUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
mb.loadObject();
super.genContentUnmarshal(mb);
mb.appendPOP();
}
public void genContentMarshal(ContextMethodBuilder mb)
throws JiBXException {
mb.loadObject();
super.genContentMarshal(mb);
}
public void genNewInstance(ContextMethodBuilder mb) throws JiBXException {
throw new IllegalStateException
("Internal error - no new instance for base class");
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.println("base mapping wrapper");
m_component.print(depth+1);
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/MappingDirect.java 0000644 0001750 0001750 00000012166 11030746314 025415 0 ustar twerner twerner /*
Copyright (c) 2003-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import java.util.ArrayList;
import org.jibx.binding.classes.BoundClass;
import org.jibx.binding.classes.ClassFile;
import org.jibx.runtime.JiBXException;
/**
* Direct mapping using supplied marshaller and unmarshaller.
*
* @author Dennis M. Sosnoski
*/
public class MappingDirect extends MappingBase
{
/** Direct mapping implementation. */
private final DirectObject m_mappingImpl;
/** Class file to use for added code. */
private final BoundClass m_boundClass;
/** Flag for abstract mapping. */
private final boolean m_isAbstract;
/** Flag for code added to class (if appropriate). */
private boolean m_isGenerated;
/**
* Constructor.
*
* @param contain containing binding definition structure
* @param type bound class name
* @param tname qualified type name (null if not specified)
* @param dir direct object information
* @param abs abstract mapping flag
* @throws JiBXException on mapping definition conflict
*/
public MappingDirect(IContainer contain, String type, String tname,
DirectObject dir, boolean abs) throws JiBXException {
super(contain, type, tname, dir);
m_mappingImpl = dir;
m_boundClass = BoundClass.getInstance(type, null);
m_isAbstract = abs;
}
/**
* Get the mapped class information. This implements the method used by the
* base class.
*
* @return information for mapped class
*/
public BoundClass getBoundClass() {
return m_boundClass;
}
//
// IMapping interface method definitions
public String getBoundType() {
return m_mappingImpl.getTargetClass().getName();
}
public String getReferenceType() {
return getBoundType();
}
public IComponent getImplComponent() {
return m_component;
}
public ClassFile getMarshaller() throws JiBXException {
return m_mappingImpl.getMarshaller();
}
public ClassFile getUnmarshaller() throws JiBXException {
return m_mappingImpl.getUnmarshaller();
}
public NameDefinition getName() {
return m_mappingImpl.getWrapperName();
}
public void addNamespace(NamespaceDefinition ns) {
throw new IllegalStateException
("Internal error: no namespace definition possible");
}
public boolean isAbstract() {
return m_isAbstract;
}
public boolean isBase() {
return false;
}
public void addExtension(MappingDefinition mdef) {
throw new IllegalStateException
("Internal error: no extension possible");
}
public IComponent buildRef(IContainer parent, IContextObj objc, String type,
PropertyDefinition prop) throws JiBXException {
return new DirectProperty(prop, m_mappingImpl);
}
public ArrayList getNamespaces() {
return null;
}
public void generateCode(boolean force) throws JiBXException {
if (!m_isGenerated) {
if (m_boundClass.isDirectAccess()) {
addIMarshallableMethod();
addIUnmarshallableMethod();
}
m_isGenerated = true;
}
}
public NameDefinition getWrapperName() {
return null;
}
public void setLinkages() throws JiBXException {
m_mappingImpl.setLinkages();
}
public ITypeBinding getBinding() {
return null;
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.println("mapping direct " +
m_mappingImpl.getTargetClass().getName());
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/PrecompiledBinding.java 0000644 0001750 0001750 00000026210 11202365544 026423 0 ustar twerner twerner /*
Copyright (c) 2008-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.ContextMethodBuilder;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.JiBXException;
/**
* Linkage to object marshalling/unmarshalling code for a class handled by an
* abstract mapping in a precompiled binding. This is constructed from the
* information in the binding factory, then used in the actual code generation
* processing to call the methods when referenced.
*
* @author Dennis M. Sosnoski
*/
public class PrecompiledBinding implements IComponent, ITypeBinding
{
//
// Constants and such related to code generation.
private static final String MARSHALLING_CONTEXT =
"org.jibx.runtime.impl.MarshallingContext";
private static final String UNMARSHALLING_CONTEXT =
"org.jibx.runtime.impl.UnmarshallingContext";
private static final String MARSHALLING_CONTEXT_SIG =
"Lorg/jibx/runtime/impl/MarshallingContext;";
private static final String UNMARSHALLING_CONTEXT_SIG =
"Lorg/jibx/runtime/impl/UnmarshallingContext;";
private static final String PRESENCE_TEST_SIG =
"(" + UNMARSHALLING_CONTEXT_SIG + ")Z";
private static final String PUSH_NAMESPACES_METHOD =
"org.jibx.runtime.IMarshallingContext.pushNamespaces";
private static final String PUSH_NAMESPACES_SIG =
"(Ljava/lang/String;)V";
private static final String POP_NAMESPACES_METHOD =
"org.jibx.runtime.IMarshallingContext.popNamespaces";
private static final String POP_NAMESPACES_SIG = "()V";
//
// Actual instance data.
/** Class handled by binding. */
private final ClassFile m_class;
/** New instance method name. */
private final String m_newInstanceName;
/** Complete method name (null if none). */
private final String m_completeName;
/** Prepare method name (null if none). */
private final String m_prepareName;
/** Name for attribute presence test method (null if none). */
private final String m_attributePresenceName;
/** Name for content presence test method (null if none). */
private final String m_contentPresenceName;
/** Name for unmarshal attribute method (null if none). */
private final String m_unmarshalAttributeName;
/** Name for unmarshal content method (null if none). */
private final String m_unmarshalContentName;
/** Name for marshal attribute method (null if none). */
private final String m_marshalAttributeName;
/** Name for marshal content method (null if none). */
private final String m_marshalContentName;
/** Signature used for unmarshalling (and new instance) methods. */
private final String m_unmarshalSignature;
/** Signature used for complete method. */
private final String m_completeSignature;
/** Signature used for marshalling (and prepare) methods. */
private final String m_marshalSignature;
/** Binding factory name used for activating namespace translation on
marshalling (null if translation not required). */
private final String m_factoryName;
/**
* Constructor.
*
* @param index abstract mapping index in binding
* @param abmaps abstract mapping information from binding
* @param xlated translated namespaces for binding flag
* @param factname binding factory name
* @throws JiBXException on error loading class information
*/
public PrecompiledBinding(int index, String[][] abmaps, boolean xlated,
String factname) throws JiBXException {
m_class = ClassCache.requireClassFile(abmaps[IBindingFactory.ABMAP_CLASSNAME_INDEX][index]);
m_newInstanceName = abmaps[IBindingFactory.ABMAP_CREATEMETH_INDEX][index];
m_completeName = abmaps[IBindingFactory.ABMAP_COMPLETEMETH_INDEX][index];
m_prepareName = abmaps[IBindingFactory.ABMAP_PREPAREMETH_INDEX][index];
m_attributePresenceName = abmaps[IBindingFactory.ABMAP_ATTRPRESMETH_INDEX][index];
m_contentPresenceName = abmaps[IBindingFactory.ABMAP_CONTPRESMETH_INDEX][index];
m_unmarshalAttributeName = abmaps[IBindingFactory.ABMAP_ATTRUMARMETH_INDEX][index];
m_unmarshalContentName = abmaps[IBindingFactory.ABMAP_CONTUMARMETH_INDEX][index];
m_marshalAttributeName = abmaps[IBindingFactory.ABMAP_ATTRMARMETH_INDEX][index];
m_marshalContentName = abmaps[IBindingFactory.ABMAP_CONTMARMETH_INDEX][index];
String classig = m_class.getSignature();
String basesig = "(" + classig + UNMARSHALLING_CONTEXT_SIG + ")";
m_unmarshalSignature = basesig + classig;
m_completeSignature = basesig + "V";
m_marshalSignature = "(" + classig + MARSHALLING_CONTEXT_SIG + ")V";
m_factoryName = xlated ? factname : null;
}
//
// IComponent interface method definitions
public boolean isOptional() {
return false;
}
public void genAttributeUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_unmarshalAttributeName != null) {
mb.loadContext(UNMARSHALLING_CONTEXT);
mb.appendCallStatic(m_unmarshalAttributeName, m_unmarshalSignature);
}
}
public void genAttributeMarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_marshalAttributeName != null) {
if (m_factoryName != null) {
mb.loadContext();
mb.appendLoadConstant(m_factoryName);
mb.appendCallInterface(PUSH_NAMESPACES_METHOD,
PUSH_NAMESPACES_SIG);
}
mb.loadContext(MARSHALLING_CONTEXT);
mb.appendCallStatic(m_marshalAttributeName, m_marshalSignature);
if (m_factoryName != null) {
mb.loadContext();
mb.appendCallInterface(POP_NAMESPACES_METHOD,
POP_NAMESPACES_SIG);
}
}
}
public void genContentUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_unmarshalContentName != null) {
mb.loadContext(UNMARSHALLING_CONTEXT);
mb.appendCallStatic(m_unmarshalContentName, m_unmarshalSignature);
}
}
public void genContentMarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_marshalContentName != null) {
if (m_factoryName != null) {
mb.loadContext();
mb.appendLoadConstant(m_factoryName);
mb.appendCallInterface(PUSH_NAMESPACES_METHOD,
PUSH_NAMESPACES_SIG);
}
mb.loadContext(MARSHALLING_CONTEXT);
mb.appendCallStatic(m_marshalContentName, m_marshalSignature);
if (m_factoryName != null) {
mb.loadContext();
mb.appendCallInterface(POP_NAMESPACES_METHOD,
POP_NAMESPACES_SIG);
}
}
}
public void genNewInstance(ContextMethodBuilder mb) throws JiBXException {
if (m_newInstanceName != null) {
mb.loadContext(UNMARSHALLING_CONTEXT);
mb.appendCallStatic(m_newInstanceName, m_unmarshalSignature);
}
}
public void genAttrPresentTest(ContextMethodBuilder mb) throws JiBXException {
if (m_attributePresenceName != null) {
mb.loadContext(UNMARSHALLING_CONTEXT);
mb.appendCallStatic(m_attributePresenceName, PRESENCE_TEST_SIG);
}
}
public void genContentPresentTest(ContextMethodBuilder mb) throws JiBXException {
if (m_contentPresenceName != null) {
mb.loadContext(UNMARSHALLING_CONTEXT);
mb.appendCallStatic(m_contentPresenceName, PRESENCE_TEST_SIG);
}
}
public String getType() {
return m_class.getName();
}
public boolean hasId() {
return false;
}
public void genLoadId(ContextMethodBuilder mb) {
throw new IllegalStateException("Internal error: id not usable with abstract precompiled binding");
}
public void setLinkages() {}
public NameDefinition getWrapperName() {
return null;
}
public boolean hasAttribute() {
return m_unmarshalAttributeName != null ||
m_marshalAttributeName != null;
}
public boolean hasContent() {
return m_unmarshalContentName != null || m_marshalContentName != null;
}
//
// ITypeBinding interface method definitions
public String getAttributeMarshalMethod() throws JiBXException {
return m_marshalAttributeName;
}
public String getAttributePresentTestMethod() throws JiBXException {
return m_attributePresenceName;
}
public String getAttributeUnmarshalMethod() throws JiBXException {
return m_unmarshalAttributeName;
}
public String getCompleteMethod() throws JiBXException {
return m_completeName;
}
public String getContentMarshalMethod() throws JiBXException {
return m_marshalContentName;
}
public String getContentPresentTestMethod() throws JiBXException {
return m_contentPresenceName;
}
public String getContentUnmarshalMethod() throws JiBXException {
return m_unmarshalContentName;
}
public String getCreateMethod() throws JiBXException {
return m_newInstanceName;
}
public String getPrepareMethod() throws JiBXException {
return m_prepareName;
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.println("precompiled binding for " + m_class.getName());
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/StructureReference.java 0000644 0001750 0001750 00000013110 11175704114 026476 0 ustar twerner twerner /*
Copyright (c) 2003-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.ContextMethodBuilder;
import org.jibx.runtime.JiBXException;
/**
* Reference to a structure definition. This is used as a placeholder when
* building the component structure of a binding definition. It's necessary
* because the referenced structure may not have been parsed yet. During the
* linkage phase that follows parsing this looks up the appropriate structure
* definition and sets up the corresponding component structure. Thereafter it
* operates as a simple pass-through wrapper for the top child component.
*
* @author Dennis M. Sosnoski
*/
public class StructureReference extends PassThroughComponent
{
/** Containing binding component. */
private final IContainer m_container;
/** Containing binding definition structure. */
private final IContextObj m_contextObject;
/** Property definition (may be null). */
private final PropertyDefinition m_property;
/** Identifier for referenced structure definition. */
private final String m_label;
/** Flag for marshalling code generation to be skipped by component. */
private boolean m_skipMarshal;
/** Object load needed for marshalling flag (used with object binding). */
private boolean m_needLoad;
/**
* Constructor.
*
* @param contain containing binding component
* @param label reference structure identifier
* @param prop property definition (may be null)
* @param hasname element name used with reference flag
* @param cobj context object
*/
public StructureReference(IContainer contain, String label,
PropertyDefinition prop, boolean hasname, IContextObj cobj) {
super();
m_container = contain;
m_contextObject = cobj;
m_property = prop;
m_skipMarshal = hasname && prop != null && prop.isOptional();
m_label = label;
}
//
// IComponent interface method definitions (overrides of defaults)
public void genAttributeMarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_needLoad) {
mb.loadObject();
}
m_component.genAttributeMarshal(mb);
}
public void genContentMarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_needLoad) {
mb.loadObject();
}
m_component.genContentMarshal(mb);
}
public void setLinkages() throws JiBXException {
// find the structure being used
DefinitionContext defc = m_container.getDefinitionContext();
IComponent impl = defc.getNamedStructure(m_label);
// verify compatible use of structure
String type = (m_property == null) ?
m_contextObject.getBoundClass().getClassName() :
m_property.getTypeName();
ClassFile cf = ClassCache.requireClassFile(type);
String itype = impl.getType();
if (!cf.isSuperclass(itype)) {
throw new JiBXException("Reference to structure " + m_label +
" has object of type " + type + " rather than required " +
itype);
}
// generate component matching mapping type
IComponent wrap;
if (impl instanceof DirectObject) {
wrap = new DirectProperty(m_property, (DirectObject)impl);
} else if (m_property == null || m_property.isImplicit()) {
wrap = impl;
m_needLoad = impl instanceof ObjectBinding;
} else {
wrap = new ComponentProperty(m_property, impl, m_skipMarshal);
}
// set the wrapped component used for all other calls
setWrappedComponent(wrap);
m_component.setLinkages();
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.print("structure reference to " + m_label);
if (m_property != null) {
System.out.println(" using " + m_property.toString());
}
System.out.println();
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/IContainer.java 0000644 0001750 0001750 00000005030 10071714302 024706 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
/**
* Containing binding definitions structure interface. This interface is
* implemented by components corresponding to elements in the binding definition
* that can contain other elements. It supplies a context for resolving
* reference to mappings, formats, or labeled structures, and for inherited
* settings.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public interface IContainer
{
/**
* Check if content children are ordered.
*
* @return true if ordered, false if not
*/
public boolean isContentOrdered();
/**
* Get default style for value expression.
*
* @return default style type for values
*/
public int getStyleDefault();
/**
* Get definition context for binding element.
*
* @return binding definition context
*/
public DefinitionContext getDefinitionContext();
/**
* Get root of binding definition.
*
* @return binding definition root
*/
public BindingDefinition getBindingRoot();
}
libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/NamespaceDefinition.java 0000644 0001750 0001750 00000012304 11147311510 026561 0 ustar twerner twerner /*
Copyright (c) 2003-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
/**
* Namespace definition from binding.
*
* @author Dennis M. Sosnoski
*/
public class NamespaceDefinition
{
//
// Enumeration for namespace usage.
/*package*/ static final int NODEFAULT_USAGE = 0;
/*package*/ static final int ELEMENTS_USAGE = 1;
/*package*/ static final int ATTRIBUTES_USAGE = 2;
/*package*/ static final int ALLDEFAULT_USAGE = 3;
//
// Actual instance data
/** Namespace URI. */
private String m_uri;
/** Namespace prefix (may be null, but not ""). */
private String m_prefix;
/** Index in namespace table for binding. */
private int m_index;
/** Use by default for nested elements. */
private boolean m_elementDefault;
/** Use by default for nested attributes. */
private boolean m_attributeDefault;
/**
* Constructor.
*
* @param uri namespace URI
* @param prefix namespace prefix (may be null for default
* namespace, but not "")
* @param usage code for default usage of namespace
*/
public NamespaceDefinition(String uri, String prefix, int usage) {
m_uri = uri;
m_prefix = prefix;
m_elementDefault =
(usage == ALLDEFAULT_USAGE) || (usage == ELEMENTS_USAGE);
m_attributeDefault =
(usage == ALLDEFAULT_USAGE) || (usage == ATTRIBUTES_USAGE);
}
/**
* Check if default namespace for attributes.
*
* @return true if default namespace for attributes,
* false if not
*/
public boolean isAttributeDefault() {
return m_attributeDefault;
}
/**
* Check if default namespace for elements.
*
* @return true if default namespace for elements,
* false if not
*/
public boolean isElementDefault() {
return m_elementDefault;
}
/**
* Set prefix for namespace.
*
* @param prefix namespace prefix (may be null, but not "")
*/
public void setPrefix(String prefix) {
m_prefix = prefix;
}
/**
* Get prefix for namespace.
*
* @return namespace prefix (may be null, but not "")
*/
public String getPrefix() {
return m_prefix;
}
/**
* Get namespace URI.
*
* @return namespace URI
*/
public String getUri() {
return m_uri;
}
/**
* Set namespace index.
*
* @param index namespace index
*/
public void setIndex(int index) {
m_index = index;
}
/**
* Get namespace index.
*
* @return namespace index
*/
public int getIndex() {
return m_index;
}
/**
* Instance builder with supplied values. Used for canned definitions.
*
* @param uri namespace URI
* @param prefix namespace prefix
*/
public static NamespaceDefinition buildNamespace(String uri,
String prefix) {
return new NamespaceDefinition(uri, prefix, NODEFAULT_USAGE);
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.print("namespace " + m_uri);
if (m_attributeDefault || m_elementDefault) {
System.out.print(" (default ");
if (m_elementDefault) {
System.out.print("elements");
if (m_attributeDefault) {
System.out.print(" and attributes");
}
} else {
System.out.print("attributes");
}
System.out.print(')');
}
if (m_prefix != null) {
System.out.print(" (prefix " + m_prefix + ")");
}
System.out.println();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/OptionalStructureWrapper.java 0000644 0001750 0001750 00000006605 10624253474 027747 0 ustar twerner twerner /*
Copyright (c) 2003-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.jibx.binding.classes.*;
import org.jibx.runtime.JiBXException;
/**
* Component decorator for optional structure with associated property. This
* just handles necessary glue code generation for the marshalling operations,
* where the presence of the structure needs to be tested before actually
* handling tag generation.
*/
public class OptionalStructureWrapper extends PassThroughComponent
{
/** Property definition. */
private final PropertyDefinition m_property;
/** Load object for marshalling code generation flag. */
private final boolean m_loadMarshal;
/**
* Constructor.
*
* @param wrap wrapped binding component
* @param load flag for need to load object for marshalling code
*/
public OptionalStructureWrapper(IComponent wrap, PropertyDefinition prop,
boolean load) {
super(wrap);
m_property = prop;
m_loadMarshal = load;
}
//
// IComponent interface method definitions
public void genAttributeMarshal(ContextMethodBuilder mb)
throws JiBXException {
mb.loadObject();
BranchWrapper ifmiss = m_property.genTest(mb);
super.genAttributeMarshal(mb);
mb.targetNext(ifmiss);
}
public void genContentMarshal(ContextMethodBuilder mb)
throws JiBXException {
mb.loadObject();
BranchWrapper ifmiss = m_property.genTest(mb);
if (m_loadMarshal) {
mb.loadObject();
m_property.genLoad(mb);
}
super.genContentMarshal(mb);
mb.targetNext(ifmiss);
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.print("optional structure wrapper " + m_property.toString());
if (m_loadMarshal) {
System.out.print(" (load marshal)");
}
System.out.println();
m_component.print(depth+1);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/ObjectStringConversion.java 0000644 0001750 0001750 00000043670 11526053666 027351 0 ustar twerner twerner /*
Copyright (c) 2003-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.jibx.binding.classes.*;
import org.jibx.runtime.JiBXException;
/**
* Object string conversion handling. Defines serialization handling for
* converting objects to and from a String value. The default is
* to just use the object toString() method for serialization and
* a constructor from a String value for deserialization.
* java.lang.String itself is a special case, with no added code
* used by default for either serializing or deserializing.
* java.lang.Object is also a special case, with no added code
* used by default for deserializing (the String value is used
* directly). Other classes must either implement toString() and
* a constructor from String, or use custom serializers and/or
* deserializers.
*
* @author Dennis M. Sosnoski
*/
public class ObjectStringConversion extends StringConversion
{
//
// Constants for code generation.
private static final String TOSTRING_METHOD = "toString";
private static final String TOSTRING_SIGNATURE =
"()Ljava/lang/String;";
private static final String FROMSTRING_SIGNATURE =
"(Ljava/lang/String;)V";
private static final String NAME_METHOD = "name";
private static final String NAME_SIGNATURE =
"()Ljava/lang/String;";
//
// Actual instance data
/** Flag for conversion from String needed (type is anything
other than String or Object) */
private boolean m_needDeserialize;
/** Initializer used for creating instance from String
(only used if no conversion needed and no deserializer supplied;
may be null) */
private ClassItem m_initFromString;
/** Flag for conversion to String needed (type is anything
other than String) */
private boolean m_needSerialize;
/** toString() method for converting instance to
String (only used if conversion needed and no serializer
supplied; may be null) */
private ClassItem m_instToString;
/**
* Constructor. Initializes conversion handling based on the supplied
* inherited handling.
*
* @param type fully qualified name of class handled by conversion
* @param inherit conversion information inherited by this conversion
* @throws JiBXException if error in configuration
*/
/*package*/ ObjectStringConversion(String type,
ObjectStringConversion inherit)
throws JiBXException {
super(type, inherit);
if (type.equals(inherit.m_typeName)) {
m_needDeserialize = inherit.m_needDeserialize;
m_initFromString = inherit.m_initFromString;
m_needSerialize = inherit.m_needSerialize;
m_instToString = inherit.m_instToString;
} else {
initMethods(true);
}
}
/**
* Constructor. Initializes conversion handling based on argument values.
* This form is only used for constructing the default set of conversions.
* Because of this, it throws an unchecked exception on error.
*
* @param dflt default value object (wrapped value for primitive types,
* otherwise String)
* @param ser fully qualified name of serialization method
* (null if none)
* @param deser fully qualified name of deserialization method
* (null if none)
* @param type fully qualified name of class handled by conversion
*/
/*package*/ ObjectStringConversion(Object dflt, String ser, String deser,
String type) {
super(dflt, ser, null, deser, type);
try {
initMethods(false);
} catch (JiBXException ex) {
throw new IllegalArgumentException(ex.getMessage());
}
}
/**
* Initialize methods used for conversion of types without serializer or
* deserializer. Sets flags for types needed, with errors thrown at time
* of attempted use rather than at definition time. That offers the
* advantages of simpler handling (we don't need to know which directions
* are supported in a binding) and more flexibility (can support nested
* partial definitions cleanly).
*
* @param require class loading required flag
*/
private void initMethods(boolean require) throws JiBXException {
if (!"java.lang.String".equals(m_typeName)) {
ClassFile cf = require ? ClassCache.requireClassFile(m_typeName) :
ClassCache.getClassFile(m_typeName);
if (cf == null) {
// no class file found, assume both serializer and deserializer
m_needDeserialize = m_needSerialize = true;
} else {
// check for Java 5 enum deserialization
if (!"java.lang.Object".equals(m_typeName)) {
boolean needdeser = true;
ClassFile sclas = cf;
while ((sclas = sclas.getSuperFile()) != null) {
if (sclas.getName().equals("java.lang.Enum")) {
setDeserializer(m_typeName + '.' + "valueOf");
needdeser = false;
if (m_instToString == null) {
m_instToString =
cf.getMethod(NAME_METHOD, NAME_SIGNATURE);
}
break;
}
}
m_needDeserialize = needdeser;
}
// set remaining methods and flags
m_needSerialize = true;
m_initFromString = cf.getInitializerMethod(FROMSTRING_SIGNATURE);
if (m_instToString == null) {
m_instToString =
cf.getMethod(TOSTRING_METHOD, TOSTRING_SIGNATURE);
}
}
}
}
/**
* Generate code to convert String representation. The
* code generated by this method assumes that the String
* value has already been pushed on the stack. It consumes this and
* leaves the converted value on the stack.
*
* @param mb method builder
* @throws JiBXException
*/
public void genFromText(ContextMethodBuilder mb) throws JiBXException {
// handle whitespace conversion, if required
if (m_converter != null) {
mb.appendCall(m_converter);
}
if (m_deserializer != null || m_initFromString != null ||
m_needDeserialize) {
// first generate code to duplicate value and check for null, with
// duplicate replaced by explicit null if already null (confusing
// in the bytecode, but will be optimized out by any native code
// generation)
mb.appendDUP();
BranchWrapper ifnnull = mb.appendIFNONNULL(this);
mb.appendPOP();
mb.appendACONST_NULL();
BranchWrapper toend = mb.appendUnconditionalBranch(this);
mb.targetNext(ifnnull);
// check if a deserializer is used for this type
if (m_deserializer != null) {
// just generate call to the deserializer (adding any checked
// exceptions thrown by the deserializer to the list needing
// handling)
mb.addMethodExceptions(m_deserializer);
if (m_deserializer.getArgumentCount() > 1) {
mb.loadContext();
}
mb.appendCall(m_deserializer);
} else if (m_initFromString != null) {
// generate code to create an instance of object and pass text
// value to constructor
mb.appendCreateNew(m_typeName);
mb.appendDUP_X1();
mb.appendSWAP();
mb.appendCallInit(m_typeName, FROMSTRING_SIGNATURE);
} else if (m_needDeserialize) {
throw new JiBXException("No deserializer for " + m_typeName +
"; define deserializer or constructor from java.lang.String");
}
// finish by setting target for null case branch
mb.targetNext(toend);
}
}
/**
* Generate code to parse and convert optional attribute or element. The
* code generated by this method assumes that the unmarshalling context
* and name information for the attribute or element have already
* been pushed on the stack. It consumes these and leaves the converted
* value (or converted default value, if the item itself is missing) on
* the stack.
*
* @param attr item is an attribute (vs element) flag
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public void genParseOptional(boolean attr, ContextMethodBuilder mb)
throws JiBXException {
// first part of generated instruction sequence is to push the default
// value, then call the appropriate unmarshalling context method to get
// the value as a String
mb.appendLoadConstant((String)m_default);
String name = attr ? UNMARSHAL_OPT_ATTRIBUTE : UNMARSHAL_OPT_ELEMENT;
mb.appendCallVirtual(name, UNMARSHAL_OPT_SIGNATURE);
// second part is to actually convert to an instance of the type
genFromText(mb);
}
/**
* Generate code to parse and convert required attribute or element. The
* code generated by this method assumes that the unmarshalling context and
* name information for the attribute or element have already been pushed
* on the stack. It consumes these and leaves the converted value on the
* stack.
*
* @param attr item is an attribute (vs element) flag
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public void genParseRequired(boolean attr, ContextMethodBuilder mb)
throws JiBXException {
// first part of generated instruction sequence is a call to the
// appropriate unmarshalling context method to get the value as a
// String
String name = attr ? UNMARSHAL_REQ_ATTRIBUTE : UNMARSHAL_REQ_ELEMENT;
mb.appendCallVirtual(name, UNMARSHAL_REQ_SIGNATURE);
// second part is to actually convert to an instance of the type
genFromText(mb);
}
/**
* Shared code generation for converting instance of type to
* String. This override of the base class method checks for
* serialization using the toString method and implements that
* case directly, while calling the base class method for normal handling.
* The code generated by this method assumes that the reference to the
* instance to be converted is on the stack. It consumes the reference,
* replacing it with the corresponding String value.
*
* @param type fully qualified class name for value on stack
* @param mb marshal method builder
* @throws JiBXException if error in configuration
*/
public void genToText(String type, ContextMethodBuilder mb)
throws JiBXException {
if (m_serializer == null && m_needSerialize) {
// report error if no handling available
if (m_instToString == null) {
throw new JiBXException("No serializer for " + m_typeName +
"; define serializer or toString() method");
} else {
// generate code to call toString() method of instance (adding
// any checked exceptions thrown by the method to the list
// needing handling)
mb.addMethodExceptions(m_instToString);
mb.appendCall(m_instToString);
}
} else {
super.genToText(type, mb);
}
}
/**
* Generate code to check if an optional value is not equal to the default.
* The code generated by this method assumes that the actual value to be
* converted has already been pushed on the stack. It consumes this,
* leaving the converted text reference on the stack if it's not equal to
* the default value.
*
* @param type fully qualified class name for value on stack
* @param mb method builder
* @param extra count of extra values to be popped from stack if missing
* @return handle for branch taken when value is equal to the default
* (target must be set by caller)
* @throws JiBXException if error in configuration
*/
protected BranchWrapper genToOptionalText(String type,
ContextMethodBuilder mb, int extra) throws JiBXException {
// check if the default value is just null
if (m_default == null) {
// generate code to call the serializer and get String value on
// stack
genToText(type, mb);
return null;
} else {
// start with code to call the serializer and get the String value
// on stack
genToText(type, mb);
// add code to check if the serialized text is different from the
// default, by duplicating the returned reference, pushing the
// default, and calling the object comparison method. This is
// followed by a branch if the comparison says they're not equal
// (nonzero result, since it's a boolean value).
mb.appendDUP();
mb.appendLoadConstant((String)m_default);
mb.appendCallStatic(COMPARE_OBJECTS_METHOD,
COMPARE_OBJECTS_SIGNATURE);
BranchWrapper iffalse = mb.appendIFEQ(this);
// finish by discarding copy of object reference on stack when
// equal to the default
genPopValues(extra+1, mb);
BranchWrapper toend = mb.appendUnconditionalBranch(this);
mb.targetNext(iffalse);
return toend;
}
}
/**
* Check if the type handled by this conversion is of a primitive type.
*
* @return false to indicate object type
*/
public boolean isPrimitive() {
return false;
}
/**
* Convert text representation into default value object. For object types
* this just returns the text value.
*
* @param text value representation to be converted
* @return converted default value object
* @throws JiBXException on conversion error
*/
protected Object convertDefault(String text) throws JiBXException {
return text;
}
/**
* Derive from existing formatting information. This allows constructing
* a new instance from an existing format of the same or an ancestor
* type, with the properties of the existing format copied to the new
* instance except where overridden by the supplied values.
*
* @param type fully qualified name of class handled by conversion
* (null if inherited)
* @param ser fully qualified name of serialization method
* (null if inherited)
* @param conv fully qualified name of whitespace conversion method
* (null if inherited)
* @param dser fully qualified name of deserialization method
* (null if inherited)
* @param dflt default value text (null if inherited)
* @return new instance initialized from existing one
* @throws JiBXException if error in configuration information
*/
public StringConversion derive(String type, String ser, String conv,
String dser, String dflt) throws JiBXException {
if (type == null) {
type = m_typeName;
}
StringConversion inst = new ObjectStringConversion(type, this);
if (ser != null) {
inst.setSerializer(ser, true);
}
if (conv != null) {
inst.setWhitespaceConverter(conv);
}
if (dser != null) {
inst.setDeserializer(dser);
}
if (dflt != null) {
inst.m_default = inst.convertDefault(dflt);
}
return inst;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/DirectGeneric.java 0000644 0001750 0001750 00000021601 10435324110 025362 0 ustar twerner twerner /*
Copyright (c) 2003-2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.jibx.binding.classes.*;
import org.jibx.runtime.JiBXException;
/**
* Linkage to generic object with defined marshaller and/or unmarshaller. This
* provides methods used to generate code for marshalling and unmarshalling
* objects of types unknown at binding time, so long as they have mappings
* defined.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class DirectGeneric implements IComponent
{
//
// Constants and such related to code generation.
private static final String ISEND_METHOD =
"org.jibx.runtime.impl.UnmarshallingContext.isEnd";
private static final String ISEND_SIGNATURE = "()Z";
private static final String UNMARSHALELEMENT_METHOD =
"org.jibx.runtime.impl.UnmarshallingContext.unmarshalElement";
private static final String UNMARSHALELEMENT_SIGNATURE =
"()Ljava/lang/Object;";
private static final String MARSHALLABLE_INTERFACE =
"org.jibx.runtime.IMarshallable";
private static final String MARSHALLABLE_METHOD =
"org.jibx.runtime.IMarshallable.marshal";
private static final String MARSHALLABLE_SIGNATURE =
"(Lorg/jibx/runtime/IMarshallingContext;)V";
//
// Actual instance data.
/** Type handled by this binding. */
private final String m_type;
/** Optional property definition. */
private final PropertyDefinition m_property;
/**
* Constructor without implicit property.
*
* @param parent containing binding definition structure
* @param type fully qualified class name of object type handled by this
* binding (null if unspecified)
*/
public DirectGeneric(IContainer parent, String type) {
m_type = (type == null) ? "java.lang.Object" : type;
m_property = null;
}
/**
* Constructor with defined property.
*
* @param parent containing binding definition structure
* @param type fully qualified class name of object type handled by this
* binding (null if unspecified)
* @param prop associated property information
*/
public DirectGeneric(IContainer parent, String type,
PropertyDefinition prop) {
m_type = (type == null) ? "java.lang.Object" : type;
m_property = prop;
}
/**
* Generate presence test code for this mapping. The generated code just
* checks that a start tag is next in the document, rather than an end tag.
*
* @param mb method builder
*/
public void genTestPresent(ContextMethodBuilder mb) {
// append code to call unmarshalling context method to check for end tag
// as next in document, then invert the result
mb.loadContext();
mb.appendCallVirtual(ISEND_METHOD, ISEND_SIGNATURE);
mb.appendLoadConstant(1);
mb.appendIXOR();
}
/**
* Generate unmarshalling code for this mapping. The generated code just
* calls the generic unmarshal element method, leaving the unmarshalled
* object on the stack (after casting it, if necessary, to the appropriate
* type).
* TODO: Instead call unmarshalling method with class passed directly, for
* better error reporting.
*
* @param mb method builder
*/
public void genUnmarshal(ContextMethodBuilder mb) throws JiBXException {
// check for optional property
BranchWrapper tosave = null;
if (m_property != null && m_property.isOptional()) {
// generate code to check presence for the case of an optional
// item, with branch if so; if not present, set a null value
// with branch to be targeted at property store.
genTestPresent(mb);
BranchWrapper ifpres = mb.appendIFNE(this);
mb.appendACONST_NULL();
tosave = mb.appendUnconditionalBranch(this);
mb.targetNext(ifpres);
}
// append code to call unmarshalling context method for generic element
mb.loadContext();
mb.appendCallVirtual(UNMARSHALELEMENT_METHOD,
UNMARSHALELEMENT_SIGNATURE);
mb.appendCreateCast(m_type);
mb.targetNext(tosave);
if (m_property != null && !m_property.isImplicit() &&
!m_property.isThis()) {
mb.loadObject();
mb.appendSWAP();
m_property.genStore(mb);
}
}
/**
* Generate marshalling code for this mapping. The generated code loads the
* object reference and casts it to the generic marshal interface, then
* calls the marshal method of that interface.
*
* @param mb method builder
*/
public void genMarshal(ContextMethodBuilder mb) throws JiBXException {
// append code to cast object and call generic marshal method
BranchWrapper toend = null;
if (m_property != null && !m_property.isImplicit()) {
mb.loadObject();
m_property.genLoad(mb);
if (m_property.isOptional()) {
// generate code to check nonnull for the case of an optional item,
// with branch if so; if not present, just pop the copy with branch
// to be targeted past end.
mb.appendDUP();
BranchWrapper ifpres = mb.appendIFNONNULL(this);
mb.appendPOP();
toend = mb.appendUnconditionalBranch(this);
mb.targetNext(ifpres);
}
}
mb.appendCreateCast(MARSHALLABLE_INTERFACE);
mb.loadContext();
mb.appendCallInterface(MARSHALLABLE_METHOD, MARSHALLABLE_SIGNATURE);
mb.targetNext(toend);
}
//
// IComponent interface method definitions
public boolean isOptional() {
return false;
}
public boolean hasAttribute() {
return false;
}
public void genAttrPresentTest(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no attributes defined");
}
public void genAttributeUnmarshal(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no attributes defined");
}
public void genAttributeMarshal(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no attributes defined");
}
public boolean hasContent() {
return true;
}
public void genContentPresentTest(ContextMethodBuilder mb)
throws JiBXException {
genTestPresent(mb);
}
public void genContentUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
genUnmarshal(mb);
}
public void genContentMarshal(ContextMethodBuilder mb)
throws JiBXException {
genMarshal(mb);
}
public void genNewInstance(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no instance creation");
}
public String getType() {
return MARSHALLABLE_INTERFACE;
}
public boolean hasId() {
return false;
}
public void genLoadId(ContextMethodBuilder mb) {
throw new IllegalStateException("Internal error - no ID allowed");
}
public NameDefinition getWrapperName() {
return null;
}
public void setLinkages() {}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.println("direct generic reference" );
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/IMapping.java 0000644 0001750 0001750 00000013252 11043445700 024367 0 ustar twerner twerner /*
* Copyright (c) 2003-2008, Dennis M. Sosnoski. 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. Neither the name of JiBX nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 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 OWNER 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.jibx.binding.def;
import java.util.ArrayList;
import org.jibx.binding.classes.ClassFile;
import org.jibx.runtime.JiBXException;
/**
* Interface for mapping definitions.
*
* @author Dennis M. Sosnoski
*/
public interface IMapping extends ILinkable
{
/**
* Get class name handled by mapping.
*
* @return name of class bound by mapping
*/
String getBoundType();
/**
* Get class name of type to be assumed for references to this mapping.
*
* @return reference type class name name
*/
String getReferenceType();
/**
* Get binding component implementing mapping. This call is only valid for
* mappings with child components, not for mappings defined using
* marshallers or unmarshallers.
*
* @return binding component implementing this mapping
*/
IComponent getImplComponent();
/**
* Get marshaller class used for mapping.
*
* @return marshaller class information
* @throws JiBXException if error in configuration
*/
ClassFile getMarshaller() throws JiBXException;
/**
* Get unmarshaller class used for mapping.
*
* @return unmarshaller class information
* @throws JiBXException if error in configuration
*/
ClassFile getUnmarshaller() throws JiBXException;
/**
* Get mapped element name.
*
* @return mapped element name information (may be null if no
* element name defined for mapping)
*/
NameDefinition getName();
/**
* Get type name.
*
* @return qualified type name, in text form (null if
* unnamed)
*/
String getTypeName();
/**
* Get the mapping name used in binding tables.
*
* @return name
*/
String getMappingName();
/**
* Add namespace. This adds a namespace definition to those active for the
* mapping.
*
* @param ns namespace definition to be added
* @throws JiBXException if error in defining namespace
*/
void addNamespace(NamespaceDefinition ns) throws JiBXException;
/**
* Check if mapping is abstract.
*
* @return true if an abstract mapping, false
* if not
*/
boolean isAbstract();
/**
* Check if mapping has extensions.
*
* @return true if one or more mappings extend this mapping,
* false if not
*/
boolean isBase();
/**
* Add extension to abstract mapping. This call is only valid for abstract
* mappings.
*
* @param mdef extension mapping definition
* @throws JiBXException if configuration error
*/
void addExtension(MappingDefinition mdef) throws JiBXException;
/**
* Build reference to mapping. Constructs and returns the component for
* handling the mapping.
*
* @param parent containing binding definition structure
* @param objc current object context
* @param type mapped value type
* @param prop property definition (may be null)
* @return constructed mapping reference component
* @throws JiBXException if configuration error
*/
IComponent buildRef(IContainer parent, IContextObj objc, String type,
PropertyDefinition prop) throws JiBXException;
/**
* Get namespaces defined for mapping.
*
* @return namespace definitions (may be null if none)
*/
ArrayList getNamespaces();
/**
* Generate required code for mapping.
*
* @param force add marshaller/unmarshaller classes for abstract non-base
* mappings flag (not passed on to children)
* @throws JiBXException if error in transformation
*/
void generateCode(boolean force) throws JiBXException;
/**
* Get the actual binding for a mapping. This is only usable with mappings
* defined by a binding; if the mapping is instead defined by specifying
* marshaller and unmarshaller classes this will just return null.
*
* @return binding structure, or null if none
*/
ITypeBinding getBinding();
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/NameDefinition.java 0000644 0001750 0001750 00000012046 10732007414 025554 0 ustar twerner twerner /*
Copyright (c) 2003-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.jibx.binding.classes.MethodBuilder;
import org.jibx.runtime.JiBXException;
/**
* Named value definition from binding. This is a component of all items
* in the mapping corresponding to elements or attributes in the document.
*
* @author Dennis M. Sosnoski
*/
public class NameDefinition
{
/** Element or attribute name. */
private final String m_name;
/** Element or attribute namespace URI. */
private String m_namespace;
/** Flag for attribute name. */
private final boolean m_isAttribute;
/** Namespace index used for marshalling (derived from nesting). */
private int m_namespaceIndex;
/**
* Constructor.
*
* @param name
* @param ns
* @param attr flag for attribute name
*/
public NameDefinition(String name, String ns, boolean attr) {
m_name = name;
m_namespace = ns;
m_isAttribute = attr;
}
/**
* Get the local name.
*
* @return name
*/
public String getName() {
return m_name;
}
/**
* Get the namespace URI.
*
* @return namespace (null if no-namespace namespace)
*/
public String getNamespace() {
return m_namespace;
}
/**
* Check if namespace URI is null.
*
* @return true if URI null, false if not
*/
public boolean isNullUri() {
return m_namespace == null;
}
/**
* Generate code to push namespace URI.
*
* @param mb method builder
*/
public void genPushUri(MethodBuilder mb) {
if (m_namespace == null) {
mb.appendACONST_NULL();
} else {
mb.appendLoadConstant(m_namespace);
}
}
/**
* Generate code to push name.
*
* @param mb method builder
*/
public void genPushName(MethodBuilder mb) {
mb.appendLoadConstant(m_name);
}
/**
* Generate code to push namespace URI followed by name.
*
* @param mb method builder
*/
public void genPushUriPair(MethodBuilder mb) {
genPushUri(mb);
genPushName(mb);
}
/**
* Generate code to push namespace index followed by name.
*
* @param mb method builder
*/
public void genPushIndexPair(MethodBuilder mb) {
mb.appendLoadConstant(m_namespaceIndex);
genPushName(mb);
}
/**
* Finds the index for the namespace used with a name. If no explicit
* namespace has been set it uses the appropriate default. This is a
* separate operation from the unmarshalling in order to properly handle
* namespace definitions as children of the named binding component.
*
* @param defc definition context for namespaces
* @throws JiBXException if error in namespace handling
*/
public void fixNamespace(DefinitionContext defc) throws JiBXException {
if (m_namespace == null) {
m_namespace = defc.getDefaultURI(m_isAttribute);
m_namespaceIndex = defc.getDefaultIndex(m_isAttribute);
} else {
try {
m_namespaceIndex = defc.getNamespaceIndex
(m_namespace, m_isAttribute);
} catch (JiBXException ex) {
throw new JiBXException("Undefined or unusable namespace \"" +
m_namespace + '"');
}
}
}
// DEBUG
public String toString() {
if (m_namespace == null) {
return m_name;
} else {
return "{" + m_namespace + "}:" + m_name;
}
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/PrecompiledAbstractMapping.java 0000644 0001750 0001750 00000016650 11175704114 030136 0 ustar twerner twerner /*
Copyright (c) 2008-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import java.util.ArrayList;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.JiBXException;
/**
* Abstract mapping defined by a precompiled binding. This is constructed from
* the binding factory information for a binding which is referenced using a
* precompiled='true' attribute.
*
* @author Dennis M. Sosnoski
*/
public class PrecompiledAbstractMapping implements IMapping
{
/** Namespace index translation required flag. */
private final boolean m_translated;
/** Class linked to mapping. */
private final ClassFile m_class;
/** Qualified type name. */
private final String m_typeName;
/** Binding structure defining the mapping. */
private final PrecompiledBinding m_binding;
/** Reference type of mapping, as fully qualified class name. */
private final String m_referenceType;
/** Namespaces used by this mapping. */
private final ArrayList m_namespaces;
/** Containing context for definition. */
private final IContainer m_parent;
/** Name used for mapping in binding tables. */
private final String m_mappingName;
/**
* Constructor.
*
* @param type bound class name
* @param tname qualified type name for abstract mapping (null
* if none)
* @param mapname abstract mapping name in binding
* @param index abstract mapping index in binding
* @param factory binding factory for mapping information
* @param nsxlate namespace index translation table (null if
* none)
* @param parent containing context
* @throws JiBXException if class definition not found
*/
public PrecompiledAbstractMapping(String type, String tname, String mapname,
int index, IBindingFactory factory, int[] nsxlate, IContainer parent)
throws JiBXException {
m_translated = nsxlate != null;
m_class = ClassCache.requireClassFile(type);
m_typeName = tname;
parent.getBindingRoot().addMappingName((tname == null) ? type : tname);
m_binding = new PrecompiledBinding(index, factory.getAbstractMappings(),
m_translated, factory.getClass().getName());
m_referenceType = type;
m_namespaces = new ArrayList();
m_parent = parent;
m_mappingName = mapname;
String[] uris = factory.getNamespaces();
int[] nss = factory.getAbstractMappingNamespaces(index);
for (int i = 0; i < nss.length; i++) {
int nsi = nss[i];
String uri = uris[nsi];
NamespaceDefinition def = new NamespaceDefinition(uri, null,
NamespaceDefinition.NODEFAULT_USAGE);
if (nsxlate != null) {
nsi = nsxlate[nsi];
}
def.setIndex(nsi);
m_namespaces.add(def);
}
}
/**
* Links extension mappings to their base mappings. For precompiled mappings
* this does nothing.
*
* @throws JiBXException if error in linking
*/
public void linkMappings() throws JiBXException {
}
//
// IMapping interface method definitions
public String getBoundType() {
return m_class.getName();
}
public String getReferenceType() {
return m_referenceType;
}
public IComponent getImplComponent() {
return m_binding;
}
public ClassFile getMarshaller() {
return null;
}
public ClassFile getUnmarshaller() {
return null;
}
public NameDefinition getName() {
return null;
}
public void addNamespace(NamespaceDefinition ns) throws JiBXException {
throw new IllegalArgumentException
("Internal error - namespace cannot be added to precompiled mapping");
}
public boolean isAbstract() {
return true;
}
public boolean isBase() {
return false;
}
public void addExtension(MappingDefinition mdef) throws JiBXException {
throw new IllegalArgumentException
("Internal error - extension cannot be added to precompiled mapping");
}
public IComponent buildRef(IContainer parent, IContextObj objc, String type,
PropertyDefinition prop) throws JiBXException {
if (prop.isThis()) {
// directly incorporate base mapping definition
return new BaseMappingWrapper(m_binding);
} else {
// create reference to use mapping definition directly
ComponentProperty comp =
new ComponentProperty(prop, m_binding, false);
if (m_binding.getAttributeUnmarshalMethod() == null &&
m_binding.getContentUnmarshalMethod() == null) {
comp.setForceUnmarshal(true);
}
return comp;
}
}
public ArrayList getNamespaces() {
return m_namespaces;
}
public void generateCode(boolean force) throws JiBXException {
}
public NameDefinition getWrapperName() {
return null;
}
public ITypeBinding getBinding() {
return m_binding;
}
public String getMappingName() {
return m_mappingName;
}
public String getTypeName() {
return m_typeName;
}
//
// IMapping interface method definitions
public void setLinkages() throws JiBXException {
BindingDefinition binding = m_parent.getBindingRoot();
for (int i = 0; i < m_namespaces.size(); i++) {
NamespaceDefinition def = (NamespaceDefinition)m_namespaces.get(i);
def.setPrefix(binding.getPrefix(def.getUri()));
}
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.print("precompiled abstract mapping " + m_typeName +
" for class " + m_class.getName());
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/DefinitionContext.java 0000644 0001750 0001750 00000060704 11262211332 026317 0 ustar twerner twerner /*
Copyright (c) 2003-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.MethodBuilder;
import org.jibx.binding.util.ArrayMap;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
/**
* Nesting level for definitions in binding. This tracks namespace and mapping
* definitions that apply to all enclosed items.
*
* @author Dennis M. Sosnoski
*/
public class DefinitionContext
{
/** Containing binding definition component. */
private final IContainer m_container;
/** Containing definition context. */
private final DefinitionContext m_context;
/** Namespace used by default at this level for attributes. */
private NamespaceDefinition m_attributeDefault;
/** Namespace used by default at this level for elements. */
private NamespaceDefinition m_elementDefault;
/** Namespaces defined at level (lazy create). */
private ArrayList m_namespaces;
/** Mapping from URI to namespace definition (lazy create). */
private Map m_uriMap;
/** Mapping from override namespace definition to original (lazy create). */
private Map m_overrideMap;
/** Mapping from fully qualified class name to mapping index (lazy
create). */
private ArrayMap m_classMap;
/** Class mappings defined at level (lazy create). */
private ArrayList m_mappings;
/** Map from signatures to String conversions. */
private Map m_convertMap;
/** Map from format qnames to String conversions. */
private Map m_formatMap;
/** Named binding components (only for root context of a binding). */
private Map m_namedStructureMap;
/**
* Constructor. Uses the containing context to establish the hierarchy for
* resolving namespaces and class mappings.
*
* @param contain containing binding definition component
*/
public DefinitionContext(IContainer contain) {
m_container = contain;
m_context = contain.getDefinitionContext();
// TODO: make these lazy
m_convertMap = new HashMap();
m_formatMap = new HashMap();
if (m_context == null) {
m_namedStructureMap = new HashMap();
}
}
/**
* Check for duplicate namespace definition. This also initializes the
* namespace structures for this context the first time the method is
* called.
*
* @param def
* @return duplicate flag (either complete duplicate, or prior definition
* of same URI with prefix is present)
*/
private boolean checkDuplicateNamespace(NamespaceDefinition def) {
// create structures if not already done
if (m_namespaces == null) {
m_namespaces = new ArrayList();
m_uriMap = new HashMap();
}
// check for conflict (or duplicate) definition
String uri = def.getUri();
NamespaceDefinition prior = (NamespaceDefinition)m_uriMap.get(uri);
return prior != null && (prior.getPrefix() != null || def.getPrefix() == null);
}
/**
* Add namespace to internal tables.
*
* @param def
*/
private void internalAddNamespace(NamespaceDefinition def) {
String uri = def.getUri();
String prefix = def.getPrefix();
def.setIndex(m_container.getBindingRoot().
getNamespaceUriIndex(uri, prefix));
m_namespaces.add(def);
m_uriMap.put(uri, def);
}
/**
* Add namespace to set defined at this level. If the new namespace
* conflicts with an existing namespace at this level (in terms of default
* usage or prefix) this throws an exception.
*
* @param def namespace definition to be added (duplicates ignored)
*/
public void addNamespace(NamespaceDefinition def) {
// override prior defaults with this namespace definition
if (def.isAttributeDefault()) {
m_attributeDefault = def;
}
if (def.isElementDefault()) {
m_elementDefault = def;
}
if (checkDuplicateNamespace(def)) {
// replace current definition for URI if this one sets defaults
if (def.isAttributeDefault() || def.isElementDefault()) {
NamespaceDefinition prior =
(NamespaceDefinition)m_uriMap.put(def.getUri(), def);
def.setIndex(prior.getIndex());
if (m_overrideMap == null) {
m_overrideMap = new HashMap();
}
m_overrideMap.put(def, prior);
}
} else {
// no conflicts, add it
internalAddNamespace(def);
}
}
/**
* Add namespace declaration to set defined at this level. This method
* treats all namespaces as though they were declared with default="none".
* If the new namespace prefix conflicts with an existing namespace this
* throws an exception.
*
* @param def namespace definition to be added (duplicates ignored)
*/
public void addImpliedNamespace(NamespaceDefinition def) {
if (!checkDuplicateNamespace(def)) {
internalAddNamespace(def);
}
}
/**
* Add class mapping to set defined at this level. If the new mapping
* conflicts with an existing one at this level it throws an exception.
*
* @param def mapping definition to be added
* @throws JiBXException on mapping definition conflict
*/
public void addMapping(IMapping def) throws JiBXException {
// create structure if not already done
if (m_mappings == null) {
m_classMap = new ArrayMap();
m_mappings = new ArrayList();
}
// check for conflict on class name before adding to definitions
String name = def.getTypeName();
if (name == null) {
name = def.getReferenceType();
}
int index = m_classMap.findOrAdd(name);
if (index < m_mappings.size()) {
if (def.getTypeName() == null) {
throw new JiBXException
("Conflicting mappings for class " + name);
} else {
throw new JiBXException
("Conflicting mappings for type name " + name);
}
} else {
m_mappings.add(def);
}
}
/**
* Add named structure component to set defined at this level. If the name
* conflicts with an existing one at this level it throws an exception.
*
* @param name component name to be set
* @param comp named component
* @throws JiBXException on mapping definition conflict
*/
public void addNamedStructure(String name, IComponent comp)
throws JiBXException {
if (m_namedStructureMap == null) {
m_context.addNamedStructure(name, comp);
} else {
m_namedStructureMap.put(name, comp);
}
}
/**
* Get the default namespace for a contained name. Elements and attributes
* are treated separately, since namespace handling differs between the two.
*
* @param attr flag for attribute name
* @return default namespace URI, or null if none
*/
private NamespaceDefinition getDefaultNamespace(boolean attr) {
NamespaceDefinition ns;
if (attr) {
ns = m_attributeDefault;
} else {
ns = m_elementDefault;
}
if (ns == null && m_context != null) {
ns = m_context.getDefaultNamespace(attr);
}
return ns;
}
/**
* Get the default namespace URI for a contained name. Elements and
* attributes are treated separately, since namespace handling differs
* between the two.
*
* @param attr flag for attribute name
* @return default namespace URI, or null if none
*/
public String getDefaultURI(boolean attr) {
NamespaceDefinition ns = getDefaultNamespace(attr);
if (ns == null) {
return null;
} else {
return ns.getUri();
}
}
/**
* Get the default namespace index for a contained name. Elements and
* attributes are treated separately, since namespace handling differs
* between the two.
*
* @param attr flag for attribute name
* @return default namespace index
*/
public int getDefaultIndex(boolean attr) {
NamespaceDefinition ns = getDefaultNamespace(attr);
if (ns == null) {
return 0;
} else {
return ns.getIndex();
}
}
/**
* Get namespace index for a given URI. Finds the prefix for a URI in a
* name contained by this level, throwing an exception if the URI is not
* found or does not have a prefix.
*
* @param uri namespace URI to be found
* @param attr flag for attribute name
* @return namespace index for URI
* @throws JiBXException if URI not defined or not usable
*/
public int getNamespaceIndex(String uri, boolean attr)
throws JiBXException {
// check for namespace URI defined at this level
if (m_uriMap != null) {
NamespaceDefinition ns = (NamespaceDefinition)m_uriMap.get(uri);
while (ns != null) {
if (!attr || ns.getPrefix() != null) {
return ns.getIndex();
} else if (m_overrideMap != null){
ns = (NamespaceDefinition)m_overrideMap.get(ns);
} else {
break;
}
}
}
// if all else fails, try the higher level
if (m_context == null) {
throw new JiBXException("Namespace URI \"" + uri +
"\" not defined or not usable");
} else {
return m_context.getNamespaceIndex(uri, attr);
}
}
/**
* Get mapping definition for class if defined at this level.
*
* @param name fully qualified class name
* @return mapping definition for class, or null if not defined
*/
public IMapping getMappingAtLevel(String name) {
// check for class mapping defined at this level
if (m_classMap != null) {
// check for definition at this level
int index = m_classMap.find(name);
if (index >= 0) {
return (IMapping)m_mappings.get(index);
}
}
return null;
}
/**
* Get mapping definition for class. Finds the mapping for a fully
* qualified class name, throwing an exception if no mapping is defined.
* This can only be used during the linkage phase.
*
* @param name fully qualified class name
* @return mapping definition for class, or null if not defined
*/
public IMapping getClassMapping(String name) {
// check for class mapping defined at this level
IMapping def = getMappingAtLevel(name);
if (def == null && m_context != null) {
// try finding definition at higher level
def = m_context.getClassMapping(name);
}
return def;
}
/**
* Get nested structure by name. Finds the nested structure with the given
* name, throwing an exception if no component with that name is defined.
*
* @param name component name to be found
* @return component with given name
* @throws JiBXException if name not defined
*/
public IComponent getNamedStructure(String name) throws JiBXException {
// check for named component defined at this level
IComponent comp = null;
if (m_namedStructureMap != null) {
comp = (IComponent)m_namedStructureMap.get(name);
}
if (comp == null) {
if (m_context == null) {
throw new JiBXException("Referenced label \"" + name +
"\" not defined");
} else {
comp = m_context.getNamedStructure(name);
}
}
return comp;
}
/**
* Get mapping definitions at level.
*
* @return mapping definitions, null if none defined at level
*/
public ArrayList getMappings() {
return m_mappings;
}
/**
* Get specific conversion definition for type. Finds with an exact match
* on the class name, checking the containing definitions if a conversion
* is not found at this level.
*
* @param name fully qualified class name to be converted
* @return conversion definition for class, or null if not
* found
*/
public StringConversion getSpecificConversion(String name) {
StringConversion conv = (StringConversion)m_convertMap.get(name);
if (conv == null && m_context != null) {
conv = m_context.getSpecificConversion(name);
}
return conv;
}
/**
* Get conversion definition for class. Finds the conversion based on a
* fully qualified class name. If a specific conversion for the actual
* class is not found (either in this or a containing level) this returns
* the generic object conversion.
*
* @param clas information for target conversion class
* @return conversion definition for class
*/
public StringConversion getConversion(ClassFile clas) {
// use conversions for superclasses only
StringConversion conv = getSpecificConversion(clas.getName());
if (conv == null) {
return getNamedConversion(BindingDefinition.OBJECT_DEFAULT_NAME);
} else {
return conv;
}
}
/**
* Get named conversion definition. Finds the conversion with the supplied
* name, checking the containing definitions if the conversion is not found
* at this level.
*
* @param name conversion name to be found
* @return conversion definition for class
*/
public StringConversion getNamedConversion(QName name) {
StringConversion conv = (StringConversion)m_formatMap.get(name);
if (conv == null && m_context != null) {
conv = m_context.getNamedConversion(name);
}
return conv;
}
/**
* Add named conversion. Checks for duplicate conversions defined within
* a level with the same name.
*
* @param name format name for this conversion
* @param conv conversion definition for class
* @throws JiBXException if duplicate conversion definition
*/
public void addConversion(QName name, StringConversion conv)
throws JiBXException {
if (m_formatMap.put(name, conv) != null) {
throw new JiBXException("Duplicate conversion defined with name " +
name);
}
}
/**
* Set specific conversion definition for type. Sets the conversion based
* on a type signature, checking for duplicate conversions defined within
* a level.
*
* @param conv conversion definition for class
* @throws JiBXException if duplicate conversion definition
*/
public void setConversion(StringConversion conv)
throws JiBXException {
if (m_convertMap.put(conv.getTypeName(), conv) != null) {
throw new JiBXException("Duplicate conversion defined for type " +
conv.getTypeName());
}
}
/**
* Sets a named conversion definition.
*
* @param name format name for this conversion
* @param conv conversion definition for class
* @throws JiBXException if duplicate conversion definition
*/
public void setNamedConversion(QName name, StringConversion conv)
throws JiBXException {
addConversion(name, conv);
}
/**
* Sets a conversion definition by both type and name. Both the type and
* name are checked for duplicate conversions defined within a level.
*
* @param name format name for this conversion
* @param conv conversion definition for class
* @throws JiBXException if duplicate conversion definition
*/
public void setDefaultConversion(QName name, StringConversion conv)
throws JiBXException {
addConversion(name, conv);
setConversion(conv);
}
/**
* Check if one or more namespaces are defined in this context.
*
* @return true if namespaces are defined, false
* if not
*/
public boolean hasNamespace() {
return m_namespaces != null && m_namespaces.size() > 0;
}
/**
* Get the namespaces defined in this context
*
* @return namespace definitions (may be null if none)
*/
public ArrayList getNamespaces() {
return m_namespaces;
}
/**
* Internal method to generate code to fill array with namespace indexes.
* The code generated to this point must have the array reference on the
* stack.
*
* @param nss namespaces to be handled
* @param mb method builder for generated code
*/
private void genFillNamespaceIndexes(ArrayList nss, MethodBuilder mb) {
if (nss != null) {
for (int i = 0; i < nss.size(); i++) {
mb.appendDUP();
mb.appendLoadConstant(i);
mb.appendLoadConstant
(((NamespaceDefinition)nss.get(i)).getIndex());
mb.appendIASTORE();
}
}
}
/**
* Internal method to generate code to fill array with namespace prefixes.
* The code generated to this point must have the array reference on the
* stack.
*
* @param nss namespaces to be handled
* @param mb method builder for generated code
*/
private void genFillNamespacePrefixes(ArrayList nss, MethodBuilder mb) {
if (nss != null) {
for (int i = 0; i < nss.size(); i++) {
mb.appendDUP();
mb.appendLoadConstant(i);
String prefix = ((NamespaceDefinition)nss.get(i)).getPrefix();
if (prefix == null) {
prefix = "";
}
mb.appendLoadConstant(prefix);
mb.appendAASTORE();
}
}
}
/**
* Generate code for loading namespace index and URI arrays. The code
* creates the arrays and leaves the references on the stack.
*
* @param mb method builder for generated code
*/
public void genLoadNamespaces(MethodBuilder mb) {
// first create the array of namespace indexes
int count = m_namespaces == null ? 0 : m_namespaces.size();
mb.appendLoadConstant(count);
mb.appendCreateArray("int");
genFillNamespaceIndexes(m_namespaces, mb);
// next create the array of prefixes
mb.appendLoadConstant(count);
mb.appendCreateArray("java.lang.String");
genFillNamespacePrefixes(m_namespaces, mb);
}
/**
* Generate code. Executes code generation for each top-level mapping
* defined in this binding, which in turn propagates the code generation
* all the way down.
*
* @param verbose flag for verbose output
* @param force create marshaller/unmarshaller even for abstract non-base
* mappings flag
* @throws JiBXException if error in transformation
*/
public void generateCode(boolean verbose, boolean force)
throws JiBXException {
if (m_mappings != null) {
for (int i = 0; i < m_mappings.size(); i++) {
IMapping mapping = (IMapping)m_mappings.get(i);
if (verbose) {
System.out.println("Generating code for mapping " +
mapping.getBoundType());
}
((IMapping)m_mappings.get(i)).generateCode(force);
}
}
}
/**
* Links extension mappings to their base mappings. This must be done before
* the more general linking step in order to determine which abstract
* mappings are standalone and which are extended by other mappings
*
* @throws JiBXException if error in linking
*/
public void linkMappings() throws JiBXException {
// check if any mappings are defined
if (m_mappings != null) {
for (int i = 0; i < m_mappings.size(); i++) {
Object obj = m_mappings.get(i);
if (obj instanceof MappingDefinition) {
((MappingDefinition)obj).linkMappings();
}
}
}
}
/**
* Set linkages between binding components. This is called after all the
* basic information has been set up. All linkage to higher level
* components should be done by this method, in order to prevent problems
* due to the order of definitions between components. For the definition
* context this calls the same method on all mappings defined in this
* context.
*
* @throws JiBXException if error in configuration
*/
public void setLinkages() throws JiBXException {
// check if any mappings are defined
if (m_mappings != null) {
for (int i = 0; i < m_mappings.size(); i++) {
Object obj = m_mappings.get(i);
if (obj instanceof MappingDefinition) {
((MappingDefinition)obj).setLinkages();
}
}
}
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.print("context");
if (m_namespaces != null) {
System.out.print(" (ns#=" + m_namespaces.size() + ')');
}
if (m_mappings != null) {
System.out.print(" (mp#=" + m_mappings.size() + ')');
}
if (m_namedStructureMap != null) {
System.out.print(" (nm#=" + m_namedStructureMap.size() + ')');
}
if (m_convertMap != null) {
System.out.print(" (cv#=" + m_convertMap.size() + ')');
}
if (m_formatMap != null) {
System.out.print(" (fm#=" + m_formatMap.size() + ')');
}
System.out.println();
if (m_namespaces != null) {
for (int i = 0; i < m_namespaces.size(); i++) {
NamespaceDefinition ndef =
(NamespaceDefinition)m_namespaces.get(i);
ndef.print(depth+1);
}
}
if (m_mappings != null) {
for (int i = 0; i < m_mappings.size(); i++) {
Object obj = m_mappings.get(i);
if (obj instanceof MappingDefinition) {
MappingDefinition mdef = (MappingDefinition)obj;
mdef.print(depth+1);
} else if (obj instanceof MappingDirect) {
MappingDirect mdir = (MappingDirect)obj;
mdir.print(depth+1);
} else {
BindingDefinition.indent(depth+1);
System.out.println("unexpected type " +
obj.getClass().getName());
}
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/PrimitiveStringConversion.java 0000644 0001750 0001750 00000050662 11263560300 030074 0 ustar twerner twerner /*
Copyright (c) 2003-2009, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.jibx.binding.classes.*;
import org.jibx.runtime.JiBXException;
/**
* Primitive string conversion handling. Class for handling serialization
* converting a primitive type to and from String values.
*
* @author Dennis M. Sosnoski
*/
public class PrimitiveStringConversion extends StringConversion
{
//
// Static class references
private static ClassFile s_unmarshalClass;
{
try {
s_unmarshalClass = ClassCache.requireClassFile
("org.jibx.runtime.impl.UnmarshallingContext");
} catch (JiBXException ex) { /* no handling required */ }
}
//
// enum for comparison types of primitive values
private static final int INT_TYPE = 0;
private static final int LONG_TYPE = 1;
private static final int FLOAT_TYPE = 2;
private static final int DOUBLE_TYPE = 3;
//
// Constants for code generation.
/** Class providing basic conversion methods. */
private static final String UTILITY_CLASS_NAME =
"org.jibx.runtime.Utility";
/** Unmarshal method signature leading portion. */
private static final String UNMARSHAL_SIG_LEAD =
"(Ljava/lang/String;Ljava/lang/String;";
/** Constant argument type array for finding conversion methods. */
private static final Class[] SINGLE_STRING_ARGS =
new Class[] { String.class };
//
// Actual instance data
/** Marshalling requires conversion to text flag. */
private boolean m_isMarshalText;
/** Unmarshalling requires conversion to text flag. */
private boolean m_isUnmarshalText;
/** Unmarshalling context method for optional attribute. */
private ClassItem m_unmarshalOptAttribute;
/** Unmarshalling context method for optional element. */
private ClassItem m_unmarshalOptElement;
/** Unmarshalling context method for required attribute. */
private ClassItem m_unmarshalReqAttribute;
/** Unmarshalling context method for required element. */
private ClassItem m_unmarshalReqElement;
/** Comparison and marshal type of value (INT_TYPE, LONG_TYPE, FLOAT_TYPE,
or DOUBLE_TYPE) */
private int m_valueType;
/** Name of value type on stack. */
private String m_stackType;
/**
* Constructor. Initializes conversion handling based on the supplied
* inherited handling.
*
* @param type name of primitive type handled by conversion
* @param inherit conversion information inherited by this conversion
*/
protected PrimitiveStringConversion(String type,
PrimitiveStringConversion inherit) {
super(type, inherit);
m_isMarshalText = inherit.m_isMarshalText;
m_isUnmarshalText = inherit.m_isUnmarshalText;
m_unmarshalOptAttribute = inherit.m_unmarshalOptAttribute;
m_unmarshalOptElement = inherit.m_unmarshalOptElement;
m_unmarshalReqAttribute = inherit.m_unmarshalReqAttribute;
m_unmarshalReqElement = inherit.m_unmarshalReqElement;
m_valueType = inherit.m_valueType;
m_stackType = inherit.m_stackType;
}
/**
* Constructor. Initializes conversion handling based on argument values.
* This form is only used for constructing the default set of conversions.
*
* @param cls class of primitive type handled by conversion
* @param dflt default value object (wrapped value, or String
* or null with special deserializer)
* @param code primitive type code
* @param ts name of utility class static method for converting value to
* String
* @param fs name of utility class static method for converting
* String to value
* @param uattr unmarshalling context method name for attribute value
* @param uelem unmarshalling context method name for element value
*/
public PrimitiveStringConversion(Class cls, Object dflt, String code,
String ts, String fs, String uattr, String uelem) {
super(dflt, UTILITY_CLASS_NAME+'.'+ts, null, UTILITY_CLASS_NAME+'.'+fs,
cls.getName());
m_isMarshalText = m_isUnmarshalText = false;
String sig = UNMARSHAL_SIG_LEAD + code + ')' + code;
m_unmarshalOptAttribute = s_unmarshalClass.getMethod(uattr, sig);
m_unmarshalOptElement = s_unmarshalClass.getMethod(uelem, sig);
sig = UNMARSHAL_SIG_LEAD + ')' + code;
m_unmarshalReqAttribute = s_unmarshalClass.getMethod(uattr, sig);
m_unmarshalReqElement = s_unmarshalClass.getMethod(uelem, sig);
if (cls == Long.TYPE) {
m_valueType = LONG_TYPE;
m_stackType = "long";
} else if (cls == Float.TYPE) {
m_valueType = FLOAT_TYPE;
m_stackType = "float";
} else if (cls == Double.TYPE) {
m_valueType = DOUBLE_TYPE;
m_stackType = "double";
} else {
m_valueType = INT_TYPE;
m_stackType = "int";
}
}
/**
* Generate code to convert String representation. The
* code generated by this method assumes that the String
* value has already been pushed on the stack. It consumes this and
* leaves the converted value on the stack.
*
* @param mb method builder
*/
public void genFromText(ContextMethodBuilder mb) {
// handle whitespace conversion, if required
if (m_converter != null) {
mb.appendCall(m_converter);
}
// check if a deserializer is used for this type
if (m_deserializer != null) {
// just generate call to the deserializer (adding any checked
// exceptions thrown by the deserializer to the list needing
// handling)
mb.addMethodExceptions(m_deserializer);
if (m_deserializer.getArgumentCount() > 1) {
mb.loadContext();
}
mb.appendCall(m_deserializer);
}
}
/**
* Push default value on stack. Just adds the appropriate instruction to
* the list for the method.
*
* @param mb method builder
*/
protected void pushDefault(ContextMethodBuilder mb) {
mb.appendLoadConstant(m_default);
}
/**
* Generate code to parse and convert optional attribute or element. The
* code generated by this method assumes that the unmarshalling context
* and name information for the attribute or element have already
* been pushed on the stack. It consumes these and leaves the converted
* value (or default value, if the item itself is missing) on the stack.
*
* @param attr item is an attribute (vs element) flag
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public void genParseOptional(boolean attr, ContextMethodBuilder mb)
throws JiBXException {
// choose between custom deserializer or standard built-in method
if (m_isUnmarshalText) {
// first part of generated instruction sequence is to push the
// default value text, then call the appropriate unmarshalling
// context method to get the value as a String
String dflt;
if (m_default instanceof String || m_default == null) {
dflt = (String)m_default;
} else {
dflt = m_default.toString();
}
mb.appendLoadConstant(dflt);
String name = attr ? UNMARSHAL_OPT_ATTRIBUTE :
UNMARSHAL_OPT_ELEMENT;
mb.appendCallVirtual(name, UNMARSHAL_OPT_SIGNATURE);
// second part is to generate call to deserializer
genFromText(mb);
} else {
// generated instruction sequence just pushes the unwrapped default
// value, then calls the appropriate unmarshalling context method
// to get the value as a primitive
pushDefault(mb);
mb.appendCall(attr ?
m_unmarshalOptAttribute : m_unmarshalOptElement);
}
}
/**
* Generate code to parse and convert required attribute or element. The
* code generated by this method assumes that the unmarshalling context and
* name information for the attribute or element have already been pushed
* on the stack. It consumes these and leaves the converted value on the
* stack.
*
* @param attr item is an attribute (vs element) flag
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public void genParseRequired(boolean attr, ContextMethodBuilder mb)
throws JiBXException {
// choose between custom deserializer or standard built-in method
if (m_isUnmarshalText) {
// first part of generated instruction sequence is a call to
// the appropriate unmarshalling context method to get the value
// as a String
String name = attr ? UNMARSHAL_REQ_ATTRIBUTE :
UNMARSHAL_REQ_ELEMENT;
mb.appendCallVirtual(name, UNMARSHAL_REQ_SIGNATURE);
// second part is to generate call to deserializer
genFromText(mb);
} else {
// generated instruction sequence just calls the appropriate
// unmarshalling context method to get the value as a primitive
mb.appendCall(attr ?
m_unmarshalReqAttribute : m_unmarshalReqElement);
}
}
/**
* Generate code to check if an optional value is not equal to the default.
* The code generated by this method assumes that the actual value to be
* converted has already been pushed on the stack. It consumes this,
* leaving the converted text reference on the stack if it's not equal to
* the default value.
*
* @param type fully qualified class name for value on stack
* @param mb method builder
* @param extra count of extra values to be popped from stack if missing
* @return handle for branch taken when value is equal to the default
* (target must be set by caller)
* @throws JiBXException if error in configuration
*/
protected BranchWrapper genToOptionalText(String type,
ContextMethodBuilder mb, int extra) throws JiBXException {
// set instructions based on value size
if (m_valueType == LONG_TYPE || m_valueType == DOUBLE_TYPE) {
mb.appendDUP2();
} else {
mb.appendDUP();
}
extra++;
// first add code to check if the value is different from the default,
// by duplicating the value, pushing the default, and executing the
// appropriate branch comparison
// TODO: this should not be done inline, but necessary for now
Object value = m_default;
if (m_isUnmarshalText) {
try {
String mname = m_deserializer.getName();
String cname = m_deserializer.getClassFile().getName();
Class clas = ClassFile.loadClass(cname);
if (clas == null) {
throw new JiBXException("Deserializer class " + cname +
" not found for converting default value");
} else {
// try first to find a declared method, then a public one
Method meth;
try {
meth = clas.getDeclaredMethod(mname,
SINGLE_STRING_ARGS);
meth.setAccessible(true);
} catch (NoSuchMethodException ex) {
meth = clas.getMethod(mname, SINGLE_STRING_ARGS);
}
String text;
if (value instanceof String || value == null) {
text = (String)value;
} else {
text = value.toString();
}
value = meth.invoke(null, new Object[] { text });
}
} catch (IllegalAccessException ex) {
throw new JiBXException("Conversion method not accessible", ex);
} catch (InvocationTargetException ex) {
throw new JiBXException("Internal error", ex);
} catch (NoSuchMethodException ex) {
throw new JiBXException("Internal error", ex);
}
}
mb.appendLoadConstant(value);
BranchWrapper ifne = null;
switch (m_valueType) {
case LONG_TYPE:
mb.appendLCMP();
break;
case FLOAT_TYPE:
mb.appendFCMPG();
break;
case DOUBLE_TYPE:
mb.appendDCMPG();
break;
default:
ifne = mb.appendIF_ICMPNE(this);
break;
}
if (ifne == null) {
ifne = mb.appendIFNE(this);
}
// generate code for branch not taken case, popping the value from
// stack along with extra parameters, and branching past using code
genPopValues(extra, mb);
BranchWrapper toend = mb.appendUnconditionalBranch(this);
mb.targetNext(ifne);
genToText(m_stackType, mb);
return toend;
}
/**
* Convert text representation into default value object. This override of
* the base class method uses reflection to call the actual deserialization
* method, returning the wrapped result value. If a custom deserializer is
* defined this just returns the String value directly.
*
* @param text value representation to be converted
* @return converted default value object
* @throws JiBXException on conversion error
*/
protected Object convertDefault(String text) throws JiBXException {
if (!m_isUnmarshalText) {
try {
String mname = m_deserializer.getName();
String cname = m_deserializer.getClassFile().getName();
Class clas = ClassFile.loadClass(cname);
if (clas == null) {
throw new JiBXException("Deserializer class " + cname +
" not found for converting default value");
} else {
// try first to find a declared method, then a public one
Method meth;
try {
meth = clas.getDeclaredMethod(mname,
SINGLE_STRING_ARGS);
meth.setAccessible(true);
} catch (NoSuchMethodException ex) {
meth = clas.getMethod(mname, SINGLE_STRING_ARGS);
}
return meth.invoke(null, new Object[] { text });
}
} catch (IllegalAccessException ex) {
throw new JiBXException("Conversion method not accessible", ex);
} catch (InvocationTargetException ex) {
throw new JiBXException("Internal error", ex);
} catch (NoSuchMethodException ex) {
throw new JiBXException("Internal error", ex);
}
} else {
return text;
}
}
/**
* Check if the type handled by this conversion is of a primitive type.
*
* @return true to indicate primitive type
*/
public boolean isPrimitive() {
return true;
}
/**
* Set serializer for conversion. This override of the base class method
* sets a flag to indicate that values must be converted to text before
* they are written to a document after executing the base class processing.
*
* @param ser fully qualified class and method name of serializer
* @throws JiBXException if serializer not found or not usable
*/
protected void setSerializer(String ser) throws JiBXException {
super.setSerializer(ser, true);
m_isMarshalText = true;
}
/**
* Set whitespace converter for conversion. This override of the base class
* method sets a flag to indicate that values must be read from a document
* as text and converted as a separate step after executing the base class
* processing.
*
* @param wsconv fully qualified class and method name of whitespace
* converter
* @throws JiBXException if whitespace converter not found or not usable
*/
protected void setWhitespaceConverter(String wsconv) throws JiBXException {
super.setWhitespaceConverter(wsconv);
m_isUnmarshalText = true;
}
/**
* Set deserializer for conversion. This override of the base class method
* sets a flag to indicate that values must be read from a document as text
* and converted as a separate step after executing the base class
* processing.
*
* @param deser fully qualified class and method name of deserializer
* @throws JiBXException if deserializer not found or not usable
*/
protected void setDeserializer(String deser) throws JiBXException {
super.setDeserializer(deser);
m_isUnmarshalText = true;
}
/**
* Derive from existing formatting information. This allows constructing
* a new instance from an existing format of the same or an ancestor
* type, with the properties of the existing format copied to the new
* instance except where overridden by the supplied values.
*
* @param type fully qualified name of class handled by conversion
* (null if inherited)
* @param ser fully qualified name of serialization method
* (null if inherited)
* @param conv fully qualified name of whitespace conversion method
* (null if inherited)
* @param dser fully qualified name of deserialization method
* (null if inherited)
* @param dflt default value text (null if inherited)
* @return new instance initialized from existing one
* @throws JiBXException if error in configuration information
*/
public StringConversion derive(String type, String ser, String conv,
String dser, String dflt) throws JiBXException {
if (type == null) {
type = m_typeName;
}
StringConversion inst = new PrimitiveStringConversion(type, this);
if (ser != null) {
inst.setSerializer(ser, true);
}
if (conv != null) {
inst.setWhitespaceConverter(conv);
}
if (dser != null) {
inst.setDeserializer(dser);
}
if (dflt != null) {
inst.m_default = inst.convertDefault(dflt);
}
return inst;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/PassThroughComponent.java 0000644 0001750 0001750 00000010505 10435324110 027006 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.jibx.binding.classes.ContextMethodBuilder;
import org.jibx.runtime.JiBXException;
/**
* Default component decorator. This just passes through all method calls to
* the wrapped component.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class PassThroughComponent implements IComponent
{
/** Property value binding component. */
protected IComponent m_component;
/**
* No argument constructor. This requires the component to be set later,
* using the {@link #setWrappedComponent} method.
*/
protected PassThroughComponent() {}
/**
* Constructor.
*
* @param comp wrapped component
*/
protected PassThroughComponent(IComponent comp) {
m_component = comp;
}
/**
* Set the wrapped component.
*
* @param comp wrapped component
*/
protected void setWrappedComponent(IComponent comp) {
m_component = comp;
}
//
// IComponent interface method definitions
public boolean isOptional() {
return m_component.isOptional();
}
public boolean hasAttribute() {
return m_component.hasAttribute();
}
public void genAttrPresentTest(ContextMethodBuilder mb)
throws JiBXException {
m_component.genAttrPresentTest(mb);
}
public void genAttributeUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
m_component.genAttributeUnmarshal(mb);
}
public void genAttributeMarshal(ContextMethodBuilder mb)
throws JiBXException {
m_component.genAttributeMarshal(mb);
}
public boolean hasContent() {
return m_component.hasContent();
}
public void genContentPresentTest(ContextMethodBuilder mb)
throws JiBXException {
m_component.genContentPresentTest(mb);
}
public void genContentUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
m_component.genContentUnmarshal(mb);
}
public void genContentMarshal(ContextMethodBuilder mb)
throws JiBXException {
m_component.genContentMarshal(mb);
}
public void genNewInstance(ContextMethodBuilder mb) throws JiBXException {
m_component.genNewInstance(mb);
}
public String getType() {
return m_component.getType();
}
public boolean hasId() {
return m_component.hasId();
}
public void genLoadId(ContextMethodBuilder mb) throws JiBXException {
m_component.genLoadId(mb);
}
public NameDefinition getWrapperName() {
return m_component.getWrapperName();
}
public void setLinkages() throws JiBXException {
m_component.setLinkages();
}
// DEBUG
public void print(int depth) {
throw new IllegalStateException
("Method must be overridden by subclass" +
getClass().getName());
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/PrecompiledConcreteMapping.java 0000644 0001750 0001750 00000014362 11335004630 030125 0 ustar twerner twerner /*
Copyright (c) 2008-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import java.util.ArrayList;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.runtime.JiBXException;
/**
* Concrete mapping defined by a precompiled binding. This is constructed from
* the binding factory information for a binding which is referenced using a
* precompiled='true' attribute.
*
* @author Dennis M. Sosnoski
*/
public class PrecompiledConcreteMapping implements IMapping
{
/** Class linked to mapping. */
private final ClassFile m_class;
/** Name of this mapping in binding.. */
private final String m_mappingName;
/** Mapped element name. */
private final NameDefinition m_name;
/** Containing context for definition. */
private final IContainer m_container;
/** Binding factory name used for activating namespace translation on
marshalling (null if translation not required). */
private final String m_factoryName;
/** Marshaller class. */
private ClassFile m_marshaller;
/** Unmarshaller class. */
private ClassFile m_unmarshaller;
/**
* Constructor.
*
* @param mapname mapping name in binding
* @param type bound class name
* @param name element name definition
* @param marname marshaller class name (null if none)
* @param umarname unmarshaller class name (null if none)
* @param parent containing context
* @param xlated translated namespaces for binding flag
* @param factname binding factory name
* @throws JiBXException if class definition not found
*/
public PrecompiledConcreteMapping(String mapname, String type,
NameDefinition name, String marname, String umarname, IContainer parent,
boolean xlated, String factname) throws JiBXException {
m_class = ClassCache.requireClassFile(type);
m_mappingName = mapname;
parent.getBindingRoot().addMappingName(mapname);
m_name = name;
m_container = parent;
m_factoryName = xlated ? factname : null;
if (marname == null) {
m_marshaller = null;
} else {
m_marshaller = ClassCache.requireClassFile(marname);
}
if (umarname == null) {
m_unmarshaller = null;
} else {
m_unmarshaller = ClassCache.requireClassFile(umarname);
}
}
/**
* Links extension mappings to their base mappings. For precompiled mappings
* this does nothing.
*
* @throws JiBXException if error in linking
*/
public void linkMappings() throws JiBXException {
}
//
// IMapping interface method definitions
public String getBoundType() {
return m_class.getName();
}
public String getReferenceType() {
return m_mappingName;
}
public IComponent getImplComponent() {
return null;
}
public ClassFile getMarshaller() {
return m_marshaller;
}
public ClassFile getUnmarshaller() {
return m_unmarshaller;
}
public NameDefinition getName() {
return m_name;
}
public void addNamespace(NamespaceDefinition ns) throws JiBXException {
throw new IllegalArgumentException
("Internal error - namespace cannot be added to precompiled mapping");
}
public boolean isAbstract() {
return false;
}
public boolean isBase() {
return false;
}
public void addExtension(MappingDefinition mdef) throws JiBXException {
throw new IllegalArgumentException
("Internal error - extension cannot be added to precompiled mapping");
}
public IComponent buildRef(IContainer parent, IContextObj objc, String type,
PropertyDefinition prop) throws JiBXException {
DirectObject dobj = new DirectObject(m_container, null, m_class, false,
m_marshaller, m_unmarshaller, m_mappingName, null, m_factoryName);
return new DirectProperty(prop, dobj);
}
public ArrayList getNamespaces() {
return null;
}
public void generateCode(boolean force) throws JiBXException {
}
public NameDefinition getWrapperName() {
return m_name;
}
public ITypeBinding getBinding() {
return null;
}
public String getMappingName() {
return m_mappingName;
}
public String getTypeName() {
return null;
}
//
// IMapping interface method definitions
public void setLinkages() throws JiBXException {
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.print("precompiled mapping class " + m_class.getName());
System.out.println(" ('" + getMappingName() + "')");
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/BindingDefinition.java 0000644 0001750 0001750 00000175230 11526300646 026260 0 ustar twerner twerner /*
Copyright (c) 2003-2010, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import org.apache.bcel.Constants;
import org.apache.bcel.generic.Type;
import org.jibx.binding.classes.BoundClass;
import org.jibx.binding.classes.BranchWrapper;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.ClassItem;
import org.jibx.binding.classes.ExceptionMethodBuilder;
import org.jibx.binding.classes.MethodBuilder;
import org.jibx.binding.classes.MungedClass;
import org.jibx.binding.util.ArrayMap;
import org.jibx.binding.util.IntegerCache;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.runtime.impl.GrowableStringArray;
/**
* Binding definition. This is the root of the object graph for a binding.
*
* @author Dennis M. Sosnoski
*/
public class BindingDefinition extends BindingBuilder.ContainerBase
implements IContainer
{
//
// Miscellaneous static data.
/** Name of object default conversion. */
static final QName OBJECT_DEFAULT_NAME = new QName("Object.default");
/** First namespace index available for user definitions. */
public static final int BASE_USER_NAMESPACE = 3;
/** Current distribution file name. This is filled in by the Ant build
process to match the current distribution. */
public static final String CURRENT_VERSION_NAME = "jibx_1_2_3_SNAPSHOT";
/** Default prefix for automatic ID generation. */
/*package*/ static final String DEFAULT_AUTOPREFIX = "id_";
/** Minimum size to use map for index from type name. */
private static final int TYPEMAP_MINIMUM_SIZE = 5;
/** Table of defined bindings. */
private static ArrayList s_bindings;
/** Classes included in any binding. */
private static ArrayMap s_mappedClasses;
//
// Static instances of predefined conversions.
private static final StringConversion s_byteConversion =
new PrimitiveStringConversion(Byte.TYPE, new Byte((byte)0), "B",
"serializeByte", "parseByte", "attributeByte", "parseElementByte");
private static final StringConversion s_charConversion =
new PrimitiveStringConversion(Character.TYPE, new Character((char)0),
"C", "serializeChar", "parseChar", "attributeChar", "parseElementChar");
private static final StringConversion s_doubleConversion =
new PrimitiveStringConversion(Double.TYPE, new Double(0.0d), "D",
"serializeDouble", "parseDouble", "attributeDouble",
"parseElementDouble");
private static final StringConversion s_floatConversion =
new PrimitiveStringConversion(Float.TYPE, new Float(0.0f), "F",
"serializeFloat", "parseFloat", "attributeFloat", "parseElementFloat");
private static final StringConversion s_intConversion =
new PrimitiveStringConversion(Integer.TYPE, new Integer(0), "I",
"serializeInt", "parseInt", "attributeInt", "parseElementInt");
private static final StringConversion s_longConversion =
new PrimitiveStringConversion(Long.TYPE, new Long(0L), "J",
"serializeLong", "parseLong", "attributeLong", "parseElementLong");
private static final StringConversion s_shortConversion =
new PrimitiveStringConversion(Short.TYPE, new Short((short)0), "S",
"serializeShort", "parseShort", "attributeShort", "parseElementShort");
private static final StringConversion s_booleanConversion =
new PrimitiveStringConversion(Boolean.TYPE, Boolean.FALSE, "Z",
"serializeBoolean", "parseBoolean", "attributeBoolean",
"parseElementBoolean");
private static final StringConversion s_dateConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.Utility.serializeDateTime",
"org.jibx.runtime.Utility.deserializeDateTime", "java.util.Date");
//#!j2me{
private static final StringConversion s_sqlDateConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.Utility.serializeSqlDate",
"org.jibx.runtime.Utility.deserializeSqlDate", "java.sql.Date");
private static final StringConversion s_sqlTimeConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.Utility.serializeSqlTime",
"org.jibx.runtime.Utility.deserializeSqlTime", "java.sql.Time");
private static final StringConversion s_timestampConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.Utility.serializeTimestamp",
"org.jibx.runtime.Utility.deserializeTimestamp", "java.sql.Timestamp");
private static final StringConversion s_jodaLocalDateConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.JodaConvert.serializeLocalDate",
"org.jibx.runtime.JodaConvert.deserializeLocalDate",
"org.joda.time.LocalDate");
private static final StringConversion s_jodaZonedDateMidnightConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.JodaConvert.serializeZonedDateMidnight",
"org.jibx.runtime.JodaConvert.deserializeZonedDateMidnight",
"org.joda.time.DateMidnight");
private static final StringConversion s_jodaLocalUnzonedDateMidnightConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.JodaConvert.serializeUnzonedDateMidnight",
"org.jibx.runtime.JodaConvert.deserializeLocalDateMidnight",
"org.joda.time.DateMidnight");
private static final StringConversion s_jodaUTCDateMidnightConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.JodaConvert.serializeUTCDateMidnight",
"org.jibx.runtime.JodaConvert.deserializeUTCDateMidnight",
"org.joda.time.DateMidnight");
private static final StringConversion s_jodaUnzonedLocalTimeConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.JodaConvert.serializeUnzonedLocalTime",
"org.jibx.runtime.JodaConvert.deserializeLocalTime",
"org.joda.time.LocalTime");
private static final StringConversion s_jodaUnzonedUTCLocalTimeConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.JodaConvert.serializeUTCLocalTime",
"org.jibx.runtime.JodaConvert.deserializeLocalTime",
"org.joda.time.LocalTime");
private static final StringConversion s_jodaZonedDateTimeConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.JodaConvert.serializeZonedDateTime",
"org.jibx.runtime.JodaConvert.deserializeZonedDateTime",
"org.joda.time.DateTime");
private static final StringConversion s_jodaUTCDateTimeConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.JodaConvert.serializeUTCDateTime",
"org.jibx.runtime.JodaConvert.deserializeUTCDateTime",
"org.joda.time.DateTime");
private static final StringConversion s_jodaLocalDateTimeConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.JodaConvert.serializeZonedDateTime",
"org.jibx.runtime.JodaConvert.deserializeLocalDateTime",
"org.joda.time.DateTime");
private static final StringConversion s_jodaStrictLocalDateTimeConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.JodaConvert.serializeZonedDateTime",
"org.jibx.runtime.JodaConvert.deserializeStrictLocalDateTime",
"org.joda.time.DateTime");
private static final StringConversion s_jodaStrictUTCDateTimeConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.JodaConvert.serializeUTCDateTime",
"org.jibx.runtime.JodaConvert.deserializeStrictUTCDateTime",
"org.joda.time.DateTime");
private static final StringConversion s_java5DecimalConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.Java5DecimalConvert.serializeDecimal",
null,
"java.math.BigDecimal");
//#j2me}
private static final StringConversion s_base64Conversion =
new ObjectStringConversion(null,
"org.jibx.runtime.Utility.serializeBase64",
"org.jibx.runtime.Utility.deserializeBase64", "byte[]");
private static final StringConversion s_wrappedBooleanConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.Utility.serializeBoolean",
"org.jibx.runtime.Utility.deserializeBoolean", "java.lang.Boolean");
private static final StringConversion s_qnameConversion =
new ObjectStringConversion(null,
"org.jibx.runtime.QName.serialize",
"org.jibx.runtime.QName.deserialize", "org.jibx.runtime.QName");
/*package*/ static final StringConversion s_stringConversion =
new ObjectStringConversion(null, null, null, "java.lang.String");
private static final StringConversion s_objectConversion =
new ObjectStringConversion(null, null, null, "java.lang.Object");
//
// Constants for code generation
private static final String FACTORY_SUFFIX = "Factory";
private static final String FACTORY_INTERFACE =
"org.jibx.runtime.IBindingFactory";
private static final String FACTORY_BASE =
"org.jibx.runtime.impl.BindingFactoryBase";
private static final String[] FACTORY_INTERFACES =
{
FACTORY_INTERFACE
};
private static final String FACTORY_INSTNAME = "m_inst";
private static final int PRIVATESTATIC_ACCESS =
Constants.ACC_PRIVATE | Constants.ACC_STATIC;
private static final int PRIVATESTATICFINAL_ACCESS =
PRIVATESTATIC_ACCESS | Constants.ACC_FINAL;
private static final String TYPEMAP_NAME = "m_typeMap";
private static final String GETINST_METHODNAME = "getInstance";
private static final String GETVERSION_METHODNAME = "getCompilerVersion";
private static final String GETDISTRIB_METHODNAME =
"getCompilerDistribution";
private static final String GETTYPEINDEX_METHODNAME = "getTypeIndex";
private static final String STRINGINT_MAPTYPE =
"org.jibx.runtime.impl.StringIntHashMap";
private static final String STRINGINTINIT_SIGNATURE = "(I)V";
private static final String STRINGINTADD_METHOD =
"org.jibx.runtime.impl.StringIntHashMap.add";
private static final String STRINGINTADD_SIGNATURE =
"(Ljava/lang/String;I)I";
private static final String STRINGINTGET_METHOD =
"org.jibx.runtime.impl.StringIntHashMap.get";
private static final String STRINGINTGET_SIGNATURE =
"(Ljava/lang/String;)I";
private static final int MAX_STRING_LENGTH = 0x7FFF;
private static final String CLASSLIST_METHOD_NAME = "getClassList";
private static final String CLASSLIST_METHOD_SIGNATURE =
"()Ljava/lang/String;";
//
// Actual instance data
/** Binding name. */
private final String m_name;
/** Index number of this binding. */
private final int m_index;
/** Input binding flag. */
private final boolean m_isInput;
/** Output binding flag. */
private final boolean m_isOutput;
/** Use global ID values flag. */
private final boolean m_isIdGlobal;
/** Support forward references to IDs flag. */
private final boolean m_isForwards;
/** Generate souce tracking interface flag. */
private final boolean m_isTrackSource;
/** Generate marshaller/unmarshaller classes for top-level non-base abstract
mappings flag. */
private final boolean m_isForceClasses;
/** Major version of binding. */
private final int m_majorVersion;
/** Minor version of binding. */
private final int m_minorVersion;
/** Add default constructors where needed flag. */
private boolean m_isAddConstructors;
/** Package for generated context factory. */
private String m_targetPackage;
/** File root for generated context factory. */
private File m_targetRoot;
/** Fully-qualified name of binding factory. */
private String m_factoryName;
/** Classes using unique (per class) identifiers. This is null
and unused when using global ID values. */
private ArrayMap m_uniqueIds;
/** Namespaces URIs included in binding. */
private ArrayMap m_namespaceUris;
/** Original prefixes for namespaces. */
private GrowableStringArray m_namespacePrefixes;
/** High mark in prefixes from from precompiled base bindings. */
private int m_highBasePrefix;
/** Outer definition context with default definitions. */
private DefinitionContext m_outerContext;
/** Inner definition context constructed for binding. */
private DefinitionContext m_activeContext;
/** Flag for done assigning indexes to mapped classes. */
private boolean m_isMappedDone;
/** Flag for schema instance namespace used in binding. */
private boolean m_isSchemaInstanceUsed;
/** Next index number for marshaller/unmarshaller slots used in-line. */
private int m_mumIndex;
/** Classes handled by in-line marshaller/unmarshaller references. */
private ArrayMap m_extraClasses;
/** Marshaller classes used in-line. */
private GrowableStringArray m_extraMarshallers;
/** Unmarshaller classes used in-line. */
private GrowableStringArray m_extraUnmarshallers;
/** Precompiled base binding names used by this binding. */
private GrowableStringArray m_baseBindings;
/** Factory class names for precompiled base bindings (same order as binding
names). */
private GrowableStringArray m_baseBindingFactories;
/** Hashes for base binding factories (same order as binding names). */
private ArrayList m_baseHashes;
/** Namespace index mapping tables for base bindings (same order as binding
names). */
private ArrayList m_baseNamespaceTables;
/** Factory classes for base bindings of base bindings. */
private GrowableStringArray m_closureFactories;
/** Namespace index mapping tables for base bindings of base bindings (same
order as factories). */
private ArrayList m_closureNamespaceTables;
/** Generated binding factory class. */
private ClassFile m_factoryClass;
/**
* Constructor. Sets all defaults, including the default name provided, and
* initializes the definition context for the outermost level of the
* binding.
*
* @param name binding name
* @param ibind input binding flag
* @param obind output binding flag
* @param tpack target package
* @param glob global IDs flag
* @param forward support forward referenced IDs flag
* @param source add source tracking for unmarshalled objects flag
* @param force create marshaller/unmarshaller classes for top-level
* non-base mappings
* @param add add default constructors where necessary flag
* @param trim trim whitespace from simple values before conversion flag
* @param major major version number
* @param minor minor version number
* @throws JiBXException if error in transformation
*/
public BindingDefinition(String name, boolean ibind, boolean obind,
String tpack, boolean glob, boolean forward, boolean source,
boolean force, boolean add, boolean trim, int major, int minor)
throws JiBXException {
// handle basic initialization
super(null);
m_name = name;
m_isInput = ibind;
m_isOutput = obind;
m_targetPackage = tpack;
m_isIdGlobal = glob;
m_isForwards = forward;
m_isTrackSource = source;
m_isForceClasses = force;
m_isAddConstructors = add;
m_majorVersion = major;
m_minorVersion = minor;
m_baseBindings = new GrowableStringArray();
m_baseBindingFactories = new GrowableStringArray();
m_baseHashes = new ArrayList();
m_baseNamespaceTables = new ArrayList();
m_closureFactories = new GrowableStringArray();
m_closureNamespaceTables = new ArrayList();
// set base class defaults
m_styleDefault = ValueChild.ELEMENT_STYLE;
m_autoLink = BindingBuilder.LINK_FIELDS;
m_accessLevel = BindingBuilder.ACC_PRIVATE;
m_nameStyle = BindingBuilder.NAME_HYPHENS;
// initialize the contexts
m_outerContext = m_activeContext = new DefinitionContext(this);
m_activeContext = new DefinitionContext(this);
m_namespaceUris = new ArrayMap();
m_namespaceUris.findOrAdd("");
m_namespacePrefixes = new GrowableStringArray();
m_namespacePrefixes.add("");
m_outerContext.addNamespace(NamespaceDefinition.buildNamespace
("http://www.w3.org/XML/1998/namespace", "xml"));
getNamespaceUriIndex
("http://www.w3.org/2001/XMLSchema-instance", "xsi");
// build the default converters in outer context, with appropriate trim
String conv = trim ? "org.jibx.runtime.WhitespaceConversions.trim" : null;
m_outerContext.setDefaultConversion(new QName("byte.default"),
s_byteConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("char.default"),
s_charConversion.derive(null, null, conv, null, null));
StringConversion schar = s_charConversion.derive("char",
"org.jibx.runtime.Utility.serializeCharString", null,
"org.jibx.runtime.Utility.parseCharString", null);
m_outerContext.setNamedConversion(new QName("char.string"), schar);
m_outerContext.setDefaultConversion(new QName("double.default"),
s_doubleConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("float.default"),
s_floatConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("int.default"),
s_intConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("long.default"),
s_longConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("short.default"),
s_shortConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("boolean.default"),
s_booleanConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("Date.default"),
s_dateConversion.derive(null, null, conv, null, null));
//#!j2me{
m_outerContext.setDefaultConversion(new QName("SqlDate.default"),
s_sqlDateConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("SqlTime.default"),
s_sqlTimeConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("Timestamp.default"),
s_timestampConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("LocalDate.default"),
s_jodaLocalDateConversion.derive(null, null, conv, null, null));
m_outerContext.setNamedConversion(new QName("DateMidnight.zoned"),
s_jodaZonedDateMidnightConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("DateMidnight.local"),
s_jodaLocalUnzonedDateMidnightConversion.derive(null, null, conv, null, null));
m_outerContext.setNamedConversion(new QName("DateMidnight.UTC"),
s_jodaUTCDateMidnightConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("LocalTime.local"),
s_jodaUnzonedLocalTimeConversion.derive(null, null, conv, null, null));
m_outerContext.setNamedConversion(new QName("LocalTime.UTC"),
s_jodaUnzonedUTCLocalTimeConversion.derive(null, null, conv, null, null));
m_outerContext.setNamedConversion(new QName("DateTime.zoned"),
s_jodaZonedDateTimeConversion.derive(null, null, conv, null, null));
m_outerContext.setNamedConversion(new QName("DateTime.UTC"),
s_jodaUTCDateTimeConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("DateTime.local"),
s_jodaLocalDateTimeConversion.derive(null, null, conv, null, null));
m_outerContext.setNamedConversion(new QName("DateTime.strict-local"),
s_jodaStrictLocalDateTimeConversion.derive(null, null, conv, null, null));
m_outerContext.setNamedConversion(new QName("DateTime.strict-UTC"),
s_jodaStrictUTCDateTimeConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("BigDecimal.java5"),
s_java5DecimalConversion.derive(null, null, conv, null, null));
//#j2me}
m_outerContext.setDefaultConversion(new QName("byte-array.default"),
s_base64Conversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("Boolean.default"),
s_wrappedBooleanConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("QName.default"),
s_qnameConversion.derive(null, null, conv, null, null));
m_outerContext.setDefaultConversion(new QName("String.default"),
s_stringConversion);
m_outerContext.setDefaultConversion(OBJECT_DEFAULT_NAME,
s_objectConversion.derive(null, null, conv, null, null));
// add this binding to list
m_index = s_bindings.size();
s_bindings.add(this);
}
/**
* Get class linked to binding element. Implementation of
* {@link org.jibx.binding.def.IContainer} interface, just returns
* null in this case.
*
* @return information for class linked by binding
*/
public BoundClass getBoundClass() {
return null;
}
/**
* Get default style for value expression. Implementation of
* {@link org.jibx.binding.def.IContainer} interface.
*
* @return default style type for values
*/
public int getStyleDefault() {
return m_styleDefault;
}
/**
* Set ID property. This parent binding component interface method should
* never be called for the binding definition, and will throw a runtime
* exception if it is called.
*
* @param child child defining the ID property
* @return false
*/
public boolean setIdChild(IComponent child) {
throw new IllegalStateException("Internal error - setIdChild for root");
}
/**
* Get default package used for code generation.
*
* @return default code generation package
*/
public String getDefaultPackage() {
return m_targetPackage;
}
/**
* Get root directory for default code generation package.
*
* @return root for default code generation
*/
public File getDefaultRoot() {
return m_targetRoot;
}
/**
* Set location for binding factory class generation.
*
* @param tpack target package for generated context factory
* @param root target root for generated context factory
*/
public void setFactoryLocation(String tpack, File root) {
m_targetPackage = tpack;
m_targetRoot = root;
}
/**
* Get index number of binding.
*
* @return index number for this binding definition
*/
public int getIndex() {
return m_index;
}
/**
* Check if binding is defined for unmarshalling.
*
* @return true if defined, false if not
*/
public boolean isInput() {
return m_isInput;
}
/**
* Check if binding is defined for marshalling.
*
* @return true if defined, false if not
*/
public boolean isOutput() {
return m_isOutput;
}
/**
* Check if global ids are used by binding.
*
* @return true if defined, false if not
*/
public boolean isIdGlobal() {
return m_isIdGlobal;
}
/**
* Check if forward ids are supported by unmarshalling binding.
*
* @return true if supported, false if not
*/
public boolean isForwards() {
return m_isForwards;
}
/**
* Check if source tracking is supported by unmarshalling binding.
*
* @return true if defined, false if not
*/
public boolean isTrackSource() {
return m_isTrackSource;
}
/**
* Check if default constructor generation is enabled.
*
* @return true if default constructor generation enabled,
* false if not
*/
public boolean isAddConstructors() {
return m_isAddConstructors;
}
/**
* Get prefix for method or class generation.
*
* @return prefix for names created by this binding
*/
public String getPrefix() {
return BindingDirectory.GENERATE_PREFIX + m_name;
}
/**
* Add mapping name to binding. If the name is not already included in any
* binding it is first added to the list of mapping names. This method is
* intended for use with <mapping> definitions. It is an error to call
* this method after calling the {@link #getMarshallerUnmarshallerName}
* method.
*
* @param name mapping name (type name if given, otherwise the fully
* qualified mapped class name)
*/
public void addMappingName(String name) {
if (m_isMappedDone) {
throw new IllegalStateException
("Internal error: Call out of sequence");
} else {
s_mappedClasses.findOrAdd(name);
}
}
/**
* Get marshaller/unmarshaller name in binding. The same class may have more
* than one marshaller/unmarshaller pair defined, so this uses the supplied
* class name as a base and appends a numeric suffix as necessary to
* generate a unique name. After the name has been assigned by this method,
* the {@link #setMarshallerUnmarshallerClasses} method must be used to set
* the actual class names.
*
* @param clas fully qualified name of class handled by
* marshaller/unmarshaller
* @return unique name for marshaller/unmarshaller pair
*/
public String getMarshallerUnmarshallerName(String clas) {
if (!m_isMappedDone) {
m_isMappedDone = true;
m_mumIndex = s_mappedClasses.size();
if (m_extraClasses == null) {
m_extraClasses = new ArrayMap();
m_extraMarshallers = new GrowableStringArray();
m_extraUnmarshallers = new GrowableStringArray();
}
}
int variant = 0;
String name = clas;
do {
name = clas + '-' + variant++;
} while (m_extraClasses.find(name) >= 0);
m_extraClasses.findOrAdd(name);
m_extraMarshallers.add(null);
m_extraUnmarshallers.add(null);
return name;
}
/**
* Set marshaller and unmarshaller class names.
*
* @param name assigned marshaller/unmarshaller name
* @param mclas fully qualified name of marshaller class
* @param uclas fully qualified name of unmarshaller class
*/
public void setMarshallerUnmarshallerClasses(String name, String mclas,
String uclas) {
int index = m_extraClasses.find(name);
m_extraMarshallers.set(index, mclas);
m_extraUnmarshallers.set(index, uclas);
}
/**
* Get index for ID'ed class from binding. If the class is not already
* included it is first added to the binding. If globally unique IDs are
* used this always returns 0.
*
* @param name fully qualified name of ID'ed class
* @return index number of class
*/
public int getIdClassIndex(String name) {
if (m_isIdGlobal) {
return 0;
} else {
if (m_uniqueIds == null) {
m_uniqueIds = new ArrayMap();
}
return m_uniqueIds.findOrAdd(name);
}
}
/**
* Get index for namespace URI in binding. If the URI is not already
* included it is first added to the binding. The empty namespace URI
* is always given index number 0.
*
* @param uri namespace URI to be included in binding
* @param prefix prefix used with namespace
* @return index number of namespace
*/
public int getNamespaceUriIndex(String uri, String prefix) {
int index = m_namespaceUris.findOrAdd(uri);
int size = m_namespacePrefixes.size();
if (index == size) {
m_namespacePrefixes.add(prefix);
} else if (index > size) {
throw new IllegalStateException("Internal error - prefixes not matched with namespaces");
}
return index;
}
/**
* Set flag for schema instance namespace used in binding.
*/
public void setSchemaInstanceUsed() {
m_isSchemaInstanceUsed = true;
}
/**
* Add a precompiled binding reference to this binding. This records the
* reference and makes sure that all the namespaces used in the precompiled
* binding are defined in this binding, also generating a namespace index
* mapping table if this binding supports output and the indexes differ.
*
* @param factory actual binding factory for precompiled binding
* @param major required major version number
* @param minor required minor version number
* @return namespace index translation table (null if none)
*/
public int[] addPrecompiledBinding(IBindingFactory factory, int major,
int minor) {
// add basic information for precompiled base binding
m_baseBindings.add(factory.getBindingName());
m_baseBindingFactories.add(factory.getClass().getName());
m_baseHashes.add(new Integer(factory.getHash()));
// add all namespaces from precompiled binding
String[] namespaces = factory.getNamespaces();
String[] prefixes = factory.getPrefixes();
int[] indexes = new int[namespaces.length];
boolean xlate = false;
for (int i = 1; i < namespaces.length; i++) {
int index = getNamespaceUriIndex(namespaces[i], prefixes[i]);
indexes[i] = index;
if (i != index) {
xlate = true;
}
}
m_highBasePrefix = m_namespacePrefixes.size();
if (xlate) {
// add translation table to list of tables for bindings
m_baseNamespaceTables.add(indexes);
// generate substitute translation tables for all base bindings
String[] basefacts = factory.getBaseBindingFactories();
Map basemap = factory.getNamespaceTranslationTableMap();
for (int i = 0; i < basefacts.length; i++) {
String factname = basefacts[i];
int[] basetable = (int[])basemap.get(factname);
if (basetable != null) {
int[] baseindexes = new int[basetable.length];
for (int j = 0; j < basetable.length; j++) {
baseindexes[j] = indexes[basetable[j]];
}
m_closureFactories.add(factname);
m_closureNamespaceTables.add(baseindexes);
}
}
return indexes;
} else {
// no need for translation table, just add null to list of tables
m_baseNamespaceTables.add(null);
return null;
}
}
/**
* Fix the prefixes for namespaces imported from precompiled base bindings.
* If there are no namespaces from precompiled base bindings, or these
* namespaces use prefixes which are unique from each other and from those
* used in this binding, nothing is done. If there are conflicts or
* namespaces used without prefixes this sets unique prefixes for each
* namespace.
*/
private void fixPrefixes() {
if (m_highBasePrefix > 0) {
Set prefset = new HashSet();
prefset.add("");
for (int i = m_highBasePrefix; i < m_namespacePrefixes.size(); i++) {
prefset.add((String)m_namespacePrefixes.get(i));
}
int genindex = 0;
for (int i = BASE_USER_NAMESPACE; i < m_highBasePrefix; i++) {
String prefix = (String)m_namespacePrefixes.get(i);
while (prefset.contains(prefix)) {
StringBuffer buff = new StringBuffer();
buff.append((char)('a' + genindex++ % 26));
int remain = genindex / 26;
while (remain > 0) {
int next = remain % 36;
if (next < 10) {
buff.append((char)('0' + next));
} else {
buff.append((char)('a' + next));
}
remain /= 36;
}
prefix = buff.toString();
}
prefset.add(prefix);
m_namespacePrefixes.set(i, prefix);
}
}
}
/**
* Get the prefix assigned for a namespace. This is intended mainly for use
* with precompiled bindings, where the {@link #fixPrefixes()} method may
* change the initial prefixes (if any) in order to avoid conflicts.
*
* @param uri namespace URI
* @return prefix for namespace
*/
public String getPrefix(String uri) {
int index = m_namespaceUris.find(uri);
if (index >= 0) {
return (String)m_namespacePrefixes.get(index);
} else {
throw new IllegalStateException("Internal error - URI not registered");
}
}
/**
* Build a class or method name blob from an array of fully-qualified class
* and/or method names. The returned string consists of compacted
* fully-qualified names separated by '|' delimiter characters. If some
* number of package (and potentially class) name levels are the same as the
* last name, these components are replaced with simple '.' characters (and
* '$' characters, in the case of class name components) in the compacted
* name. null values are represented as empty names.
*
* @param names fully-qualified class and/or method names list
* @return compacted name blob
*/
private static String buildClassNamesBlob(String[] names) {
StringBuffer buff = new StringBuffer();
String last = "";
for (int i = 0; i < names.length; i++) {
if (i > 0) {
buff.append('|');
}
String name = names[i];
if (name != null) {
int base = 0;
int limit = Math.min(last.length(), name.length());
int scan = -1;
while (++scan < limit) {
char chr = last.charAt(scan);
if (chr == name.charAt(scan)) {
if (chr == '.') {
buff.append('.');
base = scan + 1;
} else if (chr == '$') {
buff.append('$');
base = scan + 1;
}
} else {
break;
}
}
if (scan < limit ||
(scan == limit && last.length() != name.length())) {
buff.append(name.substring(base));
}
last = name;
}
}
return buff.toString();
}
/**
* Build a class or method name blob from a list of fully-qualified class
* and/or method names. This just converts the list to an array and
* delegates to {@link #buildClassNamesBlob(String[])}.
*
* @param names fully-qualified class and/or method names list
* @return compacted name blob
*/
private static String buildClassNamesBlob(List names) {
String[] strings = (String[])names.toArray(new String[names.size()]);
return buildClassNamesBlob(strings);
}
/**
* Build a namespace index blob from an array of namespace URIs. The
* returned string consists of one character per namespace, giving the index
* of the namespace URI within the array of definitions, biased by +2 to
* avoid use of null characters (with +1 used for null values).
*
* @param uris table of namespaces defined in binding
* @param nss namespaces for index blob
* @return index blob
*/
private static String buildNamespaceIndexBlob(String[] uris, String[] nss) {
Map indexmap = new HashMap();
for (int i = 0; i < uris.length; i++) {
indexmap.put(uris[i], IntegerCache.getInteger(i+2));
}
StringBuffer buff = new StringBuffer(nss.length);
for (int i = 0; i < nss.length; i++) {
String uri = nss[i];
if (uri == null) {
buff.append((char)1);
} else {
buff.append((char)((Integer)indexmap.get(uri)).intValue());
}
}
return buff.toString();
}
/**
* Build a name blob from an array of names. The returned string consists of
* names separated by '|' delimiter characters. null values are
* represented as empty names.
*
* @param names names for blob
* @return name blob
*/
private static String buildNamesBlob(String[] names) {
StringBuffer buff = new StringBuffer();
for (int i = 0; i < names.length; i++) {
if (i > 0) {
buff.append('|');
}
if (names[i] != null) {
buff.append(names[i]);
}
}
return buff.toString();
}
/**
* Convert an array of int values into a string blob.
*
* @param ints
* @return string with int values as characters
*/
private static String buildIntsBlob(int[] ints) {
char[] chars = new char[ints.length];
for (int i = 0; i < ints.length; i++) {
int value = ints[i];
if (value < 0 || value >= 0xFFFF) {
throw new IllegalArgumentException("Internal error - only 16-bit values supported at present");
}
chars[i] = (char)(value + 1);
}
return new String(chars);
}
/**
* Convert a list of Integer values into a string blob. This is
* just a convenience wrapper for {@link #buildIntsBlob(int[])}.
*
* @param values
* @return string with int values as characters
*/
private static String buildIntsBlob(List values) {
int[] ints = new int[values.size()];
for (int i = 0; i < values.size(); i++) {
ints[i] = ((Integer)values.get(i)).intValue();
}
return buildIntsBlob(ints);
}
/**
* Generate code to load a string value, which may be longer than the
* maximum string length. This either loads the string directly (if within
* the limit) or recreates it by concatenating two or more shorter strings.
*
* @param string
* @param mb
*/
private static void codegenString(String string, MethodBuilder mb) {
if (string.length() < MAX_STRING_LENGTH) {
mb.appendLoadConstant(string);
} else {
// build a StringBuffer, then loop loading each component constant
// string in turn and appending it; when all strings done, call
// StringBuffer.toString()
mb.appendCreateNew("java.lang.StringBuffer");
mb.appendDUP();
mb.appendLoadConstant(string.length());
mb.appendCallInit("java.lang.StringBuffer", "(I)V");
int base = 0;
while (base < string.length()) {
int end = Math.min(base + MAX_STRING_LENGTH, string.length());
mb.appendLoadConstant(string.substring(base, end));
mb.appendCallVirtual("java.lang.StringBuffer.append",
"(Ljava/lang/String;)Ljava/lang/StringBuffer;");
base = end;
}
mb.appendCallVirtual("java.lang.StringBuffer.toString",
"()Ljava/lang/String;");
}
}
/**
* Get the fully-qualified name of the binding factory class for this
* binding.
*
* @return class name
*/
public String getFactoryName() {
return m_factoryName;
}
/**
* Generate code. First sets linkages and executes code generation for
* each top-level mapping defined in this binding, which in turn propagates
* the code generation all the way down. Then generates the actual binding
* factory for this binding.
*
* @param verbose1 flag for verbose output from first pass
* @param verbose2 flag for verbose output from second pass
* @throws JiBXException if error in code generation
*/
public void generateCode(boolean verbose1, boolean verbose2) throws JiBXException {
// check schema instance namespace usage
if (m_isSchemaInstanceUsed) {
NamespaceDefinition xsins = NamespaceDefinition.buildNamespace
("http://www.w3.org/2001/XMLSchema-instance", "xsi");
ArrayList mappings = m_activeContext.getMappings();
for (int i = 0; i < mappings.size(); i++) {
Object mapping = mappings.get(i);
if (mapping instanceof MappingDefinition) {
((MappingDefinition)mapping).addNamespace(xsins);
}
}
}
// set the class name to be used for binding factory
if (m_targetPackage.length() == 0) {
m_factoryName = getPrefix() + FACTORY_SUFFIX;
} else {
m_factoryName = m_targetPackage + '.' + getPrefix() + FACTORY_SUFFIX;
}
// handle basic linkage and child code generation
BoundClass.setModify(m_targetRoot, m_targetPackage, m_name);
fixPrefixes();
m_activeContext.linkMappings();
m_activeContext.setLinkages();
m_activeContext.generateCode(verbose1, m_isForceClasses);
if (verbose2) {
System.out.println("After linking view of binding " + m_name + ':');
print();
}
// build the binding factory class
ClassFile base = ClassCache.requireClassFile(FACTORY_BASE);
ClassFile cf = new ClassFile(m_factoryName, m_targetRoot, base,
Constants.ACC_PUBLIC, FACTORY_INTERFACES);
// add static field for instance
ClassItem inst = cf.addField(FACTORY_INTERFACE,
FACTORY_INSTNAME, PRIVATESTATIC_ACCESS);
// add private method to return binding classes blob (replaced later)
MethodBuilder mb = new ExceptionMethodBuilder(CLASSLIST_METHOD_NAME,
Type.STRING, new Type[0], cf,
Constants.ACC_PRIVATE|Constants.ACC_STATIC);
mb.appendACONST_NULL();
mb.appendReturn(Type.STRING);
mb.codeComplete(false);
ClassItem clasblobmeth = mb.addMethod();
// add the private constructor method
mb = new ExceptionMethodBuilder("", Type.VOID, new Type[0], cf,
Constants.ACC_PRIVATE);
// start superclass constructor call with name/versions, classes used
mb.appendLoadLocal(0);
mb.appendLoadConstant(m_name);
mb.appendLoadConstant(m_majorVersion);
mb.appendLoadConstant(m_minorVersion);
mb.appendCall(clasblobmeth);
// load count of mapped classes
int count = s_mappedClasses.size();
int mcnt = m_extraClasses == null ? count : count +
m_extraClasses.size();
// create argument blob of mapped class names
String[] names = new String[mcnt];
for (int i = 0; i < count; i++) {
names[i] = (String)s_mappedClasses.get(i);
}
for (int i = count; i < mcnt; i++) {
names[i] = (String)m_extraClasses.get(i-count);
}
codegenString(buildClassNamesBlob(names), mb);
// create argument blob of unmarshaller class names
if (m_isInput) {
for (int i = 0; i < count; i++) {
String cname = (String)s_mappedClasses.get(i);
IMapping map = m_activeContext.getMappingAtLevel(cname);
if (map != null && map.getUnmarshaller() != null) {
names[i] = map.getUnmarshaller().getName();
} else {
names[i] = null;
}
}
for (int i = count; i < mcnt; i++) {
names[i] = (String)m_extraUnmarshallers.get(i-count);
}
codegenString(buildClassNamesBlob(names), mb);
} else {
mb.appendACONST_NULL();
}
// create argument blob of marshaller class names
if (m_isOutput) {
for (int i = 0; i < count; i++) {
String cname = (String)s_mappedClasses.get(i);
IMapping map = m_activeContext.getMappingAtLevel(cname);
if (map != null && map.getMarshaller() != null) {
names[i] = map.getMarshaller().getName();
} else {
names[i] = null;
}
}
for (int i = count; i < mcnt; i++) {
names[i] = (String)m_extraMarshallers.get(i-count);
}
codegenString(buildClassNamesBlob(names), mb);
} else {
mb.appendACONST_NULL();
}
// create argument array of namespace URIs
String[] nsuris = new String[m_namespaceUris.size()];
mb.appendLoadConstant(m_namespaceUris.size());
mb.appendCreateArray("java.lang.String");
for (int i = 0; i < m_namespaceUris.size(); i++) {
mb.appendDUP();
mb.appendLoadConstant(i);
String uri = (String)m_namespaceUris.get(i);
mb.appendLoadConstant(uri);
mb.appendAASTORE();
nsuris[i] = uri;
}
// create argument array of namespace prefixes
if (m_isOutput) {
mb.appendLoadConstant(m_namespacePrefixes.size());
mb.appendCreateArray("java.lang.String");
for (int i = 0; i < m_namespacePrefixes.size(); i++) {
mb.appendDUP();
mb.appendLoadConstant(i);
mb.appendLoadConstant((String)m_namespacePrefixes.get(i));
mb.appendAASTORE();
}
} else {
mb.appendACONST_NULL();
}
// create argument blobs of globally mapped element names and URIs
names = new String[count];
String[] namespaces = new String[count];
for (int i = 0; i < count; i++) {
String cname = (String)s_mappedClasses.get(i);
IMapping map = m_activeContext.getMappingAtLevel(cname);
if (map != null) {
NameDefinition ndef = map.getName();
if (ndef != null) {
names[i] = ndef.getName();
namespaces[i] = ndef.getNamespace();
}
}
}
codegenString(buildNamesBlob(names), mb);
mb.appendLoadConstant(buildNamespaceIndexBlob(nsuris, namespaces));
// create argument array of class names with unique IDs
if (m_uniqueIds != null && m_uniqueIds.size() > 0) {
mb.appendLoadConstant(m_uniqueIds.size());
mb.appendCreateArray("java.lang.String");
for (int i = 0; i < m_uniqueIds.size(); i++) {
mb.appendDUP();
mb.appendLoadConstant(i);
mb.appendLoadConstant((String)m_uniqueIds.get(i));
mb.appendAASTORE();
}
} else {
mb.appendACONST_NULL();
}
// create argument blobs of abstract mapping information
GrowableStringArray allnames = new GrowableStringArray();
int abmapcnt = 0;
StringBuffer buff = new StringBuffer();
for (int i = 0; i < count; i++) {
String tname = (String)s_mappedClasses.get(i);
IMapping map = m_activeContext.getMappingAtLevel(tname);
if (map != null && map.isAbstract()) {
ITypeBinding bind = map.getBinding();
allnames.add(tname);
allnames.add(map.getBoundType());
allnames.add(bind.getCreateMethod());
allnames.add(bind.getCompleteMethod());
allnames.add(bind.getPrepareMethod());
allnames.add(bind.getAttributePresentTestMethod());
allnames.add(bind.getAttributeUnmarshalMethod());
allnames.add(bind.getAttributeMarshalMethod());
allnames.add(bind.getContentPresentTestMethod());
allnames.add(bind.getContentUnmarshalMethod());
allnames.add(bind.getContentMarshalMethod());
abmapcnt++;
ArrayList nss = map.getNamespaces();
if (nss == null) {
buff.append((char)1);
} else {
buff.append((char)(nss.size()+1));
for (int j = 0; j < nss.size(); j++) {
NamespaceDefinition nsdef =
(NamespaceDefinition)nss.get(j);
buff.append((char)(nsdef.getIndex()+1));
}
}
}
}
codegenString(buildClassNamesBlob(allnames.toArray()), mb);
codegenString(buff.toString(), mb);
// create argument blobs of precompiled base binding names and factories
int basecount = m_baseBindings.size();
codegenString(buildNamesBlob(m_baseBindings.toArray()), mb);
String namesblob = buildClassNamesBlob(m_baseBindingFactories.toArray());
if (m_closureFactories.size() > 0) {
namesblob += "|" + buildClassNamesBlob(m_closureFactories.toArray());
}
codegenString(namesblob, mb);
// create argument blob for base binding factory hashes
char[] hashchars = new char[basecount*2];
for (int i = 0; i < basecount; i++) {
int hash = ((Integer)m_baseHashes.get(i)).intValue();
hashchars[i*2] = (char)(hash >> 16);
hashchars[i*2+1] = (char)hash;
}
codegenString(new String(hashchars), mb);
// create array of blobs of base binding namespace translation tables
mb.appendLoadConstant(basecount + m_closureNamespaceTables.size());
mb.appendCreateArray("java.lang.String");
for (int i = 0; i < basecount; i++) {
int[] table = (int[])m_baseNamespaceTables.get(i);
if (table != null) {
mb.appendDUP();
mb.appendLoadConstant(i);
mb.appendLoadConstant(buildIntsBlob(table));
mb.appendAASTORE();
}
}
for (int i = 0; i < m_closureNamespaceTables.size(); i++) {
int[] table = (int[])m_closureNamespaceTables.get(i);
mb.appendDUP();
mb.appendLoadConstant(i+basecount);
mb.appendLoadConstant(buildIntsBlob(table));
mb.appendAASTORE();
}
// call the base class constructor
mb.appendCallInit(FACTORY_BASE,
"(Ljava/lang/String;IILjava/lang/String;Ljava/lang/String;" +
"Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;" +
"[Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;" +
"[Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;" +
"Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;" +
"[Ljava/lang/String;)V");
// get class names for types (abstract non-base mappings)
GrowableStringArray tnames = new GrowableStringArray();
if (m_isForceClasses) {
for (int i = 0; i < count; i++) {
String cname = (String)s_mappedClasses.get(i);
IMapping map = m_activeContext.getMappingAtLevel(cname);
if (map != null && map.isAbstract() && !map.isBase()) {
String tname = map.getTypeName();
if (tname == null) {
tname = cname;
}
tnames.add(tname);
}
}
}
// check if map needed for types
ClassItem tmap = null;
if (tnames.size() >= TYPEMAP_MINIMUM_SIZE) {
// create field for map
tmap = cf.addPrivateField(STRINGINT_MAPTYPE, TYPEMAP_NAME);
// initialize with appropriate size
mb.appendLoadLocal(0);
mb.appendCreateNew(STRINGINT_MAPTYPE);
mb.appendDUP();
mb.appendLoadConstant(tnames.size());
mb.appendCallInit(STRINGINT_MAPTYPE, STRINGINTINIT_SIGNATURE);
// add all values to map
for (int i = 0; i < tnames.size(); i++) {
int index = s_mappedClasses.find(tnames.get(i));
if (index >= 0) {
mb.appendDUP();
mb.appendLoadConstant((String)tnames.get(i));
mb.appendLoadConstant(index);
mb.appendCallVirtual(STRINGINTADD_METHOD,
STRINGINTADD_SIGNATURE);
mb.appendPOP();
}
}
mb.appendPutField(tmap);
}
// finish with return from constructor
mb.appendReturn();
mb.codeComplete(false);
mb.addMethod();
// add the compiler version access method
mb = new ExceptionMethodBuilder(GETVERSION_METHODNAME,
Type.INT, new Type[0], cf, Constants.ACC_PUBLIC);
mb.appendLoadConstant(IBindingFactory.CURRENT_VERSION_NUMBER);
mb.appendReturn("int");
mb.codeComplete(false);
mb.addMethod();
// add the compiler distribution access method
mb = new ExceptionMethodBuilder(GETDISTRIB_METHODNAME,
Type.STRING, new Type[0], cf, Constants.ACC_PUBLIC);
mb.appendLoadConstant(CURRENT_VERSION_NAME);
mb.appendReturn(Type.STRING);
mb.codeComplete(false);
mb.addMethod();
// add the type mapping index lookup method
mb = new ExceptionMethodBuilder(GETTYPEINDEX_METHODNAME,
Type.INT, new Type[] { Type.STRING }, cf, Constants.ACC_PUBLIC);
if (tnames.size() > 0) {
if (tmap == null) {
// generate in-line compares for mapping
for (int i = 0; i < tnames.size(); i++) {
int index = s_mappedClasses.find(tnames.get(i));
if (index >= 0) {
mb.appendLoadLocal(1);
mb.appendLoadConstant((String)tnames.get(i));
mb.appendCallVirtual("java.lang.String.equals",
"(Ljava/lang/Object;)Z");
BranchWrapper onfail = mb.appendIFEQ(this);
mb.appendLoadConstant(index);
mb.appendReturn(Type.INT);
mb.targetNext(onfail);
}
}
mb.appendLoadConstant(-1);
} else {
// use map constructed in initializer
mb.appendLoadLocal(0);
mb.appendGetField(tmap);
mb.appendLoadLocal(1);
mb.appendCallVirtual(STRINGINTGET_METHOD,
STRINGINTGET_SIGNATURE);
}
} else {
// no types to handle, just always return failure
mb.appendLoadConstant(-1);
}
mb.appendReturn(Type.INT);
mb.codeComplete(false);
mb.addMethod();
// finish with instance creation method
mb = new ExceptionMethodBuilder(GETINST_METHODNAME,
ClassItem.typeFromName(FACTORY_INTERFACE), new Type[0], cf,
(short)(Constants.ACC_PUBLIC | Constants.ACC_STATIC));
mb.appendGetStatic(inst);
BranchWrapper ifdone = mb.appendIFNONNULL(this);
mb.appendCreateNew(cf.getName());
mb.appendDUP();
mb.appendCallInit(cf.getName(), "()V");
mb.appendPutStatic(inst);
mb.targetNext(ifdone);
mb.appendGetStatic(inst);
mb.appendReturn(FACTORY_INTERFACE);
mb.codeComplete(false);
mb.addMethod();
// add factory class to generated registry
cf.codeComplete();
MungedClass.addModifiedClass(cf);
m_factoryClass = cf;
// record the binding factory in each top-level mapped class
ArrayList maps = m_activeContext.getMappings();
if (maps != null) {
for (int i = 0; i < maps.size(); i++) {
IMapping map = (IMapping)maps.get(i);
if (map instanceof MappingBase) {
BoundClass bound = ((MappingBase)map).getBoundClass();
if (bound.getClassFile().isModifiable()) {
bound.addFactory(m_factoryName);
}
}
}
}
}
/**
* Generate code. This version preserves compatibility with the older form
* of the call, always passing false for the second-pass
* verbose flag. See {@link #generateCode(boolean, boolean)} for details of
* processing.
*
* @param verbose flag for verbose output from first pass
* @throws JiBXException if error in code generation
*/
public void generateCode(boolean verbose) throws JiBXException {
generateCode(verbose, false);
}
/**
* Add the list of classes used by the binding compiler to the binding
* factory. This needs to be done as a separate step after the normal
* binding process has completed in order to make sure that the full set of
* classes is available. Ugly, but necessary because the class handling
* doesn't finalize newly-generated class names until they're actually
* written (too much sophistication, in retrospect).
*
* @param adds classes added by binding
* @param keeps classes used but kept unchanged by binding
*/
public void addClassList(ClassFile[] adds, ClassFile[] keeps) {
// build a sorted tree of all the class names used in the binding
Set tree = new TreeSet();
int addcount = adds.length;
for (int i = 0; i < addcount; i++) {
tree.add(adds[i].getName());
}
for (int i = 0; i < keeps.length; i++) {
tree.add(keeps[i].getName());
}
String[] refs = (String[])tree.toArray(new String[tree.size()]);
// replace private method to return binding classes blob
m_factoryClass.deleteMethod(CLASSLIST_METHOD_NAME,
CLASSLIST_METHOD_SIGNATURE);
MethodBuilder mb = new ExceptionMethodBuilder(CLASSLIST_METHOD_NAME,
Type.STRING, new Type[0], m_factoryClass,
Constants.ACC_PRIVATE|Constants.ACC_STATIC);
codegenString(buildClassNamesBlob(refs), mb);
mb.appendReturn(Type.STRING);
mb.codeComplete(false);
mb.addMethod();
m_factoryClass.codeComplete();
}
/**
* Convenience method to get an name, if the item is defined.
*
* @param item information, or null if none
* @return item name, or null if no item
*/
private static String methodNameOrNull(ClassItem item) {
String method;
if (item == null) {
method = null;
} else {
method = item.getName();
}
return method;
}
/**
* Get indexed binding.
*
* @param index number of binding to be returned
* @return binding at the specified index
*/
public static BindingDefinition getBinding(int index) {
return (BindingDefinition)s_bindings.get(index);
}
/**
* Discard cached information and reset in preparation for a new binding
* run.
*/
public static void reset() {
s_bindings = new ArrayList();
s_mappedClasses = new ArrayMap();
}
//
// IContainer interface method definitions
public boolean isContentOrdered() {
return true;
}
public boolean hasNamespaces() {
return false;
}
public BindingDefinition getBindingRoot() {
return this;
}
public DefinitionContext getDefinitionContext() {
return m_activeContext;
}
// DEBUG
private static byte[] s_blanks =
" ".getBytes();
public static void indent(int depth) {
if (depth < s_blanks.length) {
System.out.write(s_blanks, 0, depth);
} else {
System.out.print(s_blanks);
}
}
public void print() {
System.out.println("binding " + m_name + ":");
m_activeContext.print(1);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/NestedBase.java 0000644 0001750 0001750 00000017041 11031234350 024672 0 ustar twerner twerner /*
Copyright (c) 2003-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import java.util.ArrayList;
import org.jibx.binding.classes.*;
import org.jibx.runtime.JiBXException;
/**
* Base class for structure and collection binding definitions. This handles one
* or more child components, which may be ordered or unordered.
*
* @author Dennis M. Sosnoski
*/
public abstract class NestedBase extends BindingBuilder.ContainerBase
implements IComponent, IContainer
{
/** Context object for this definition. */
private IContextObj m_contextObject;
/** Flag for context defined at level. */
private final boolean m_hasContext;
/** Flag for ordered child content (used by subclasses). */
protected final boolean m_isOrdered;
/** Flag for flexible element handling (used by subclasses). */
protected final boolean m_isFlexible;
/** Definition context for container (may be same as parent). */
private final DefinitionContext m_defContext;
/** Included attribute definitions (lazy create, only if needed). */
protected ArrayList m_attributes;
/** Nested content definitions (initially used for all child components). */
protected ArrayList m_contents;
/**
* Constructor.
*
* @param contain containing binding definition context
* @param objc current object context
* @param ord ordered content flag
* @param flex flexible element handling flag
* @param defc define context for structure flag
*/
public NestedBase(IContainer contain, IContextObj objc,
boolean ord, boolean flex, boolean defc) {
// set base class defaults
super(contain);
m_styleDefault = m_autoLink = m_accessLevel = m_nameStyle = -1;
// initialize members at this level
m_contextObject = objc;
m_contents = new ArrayList();
m_isOrdered = ord;
m_isFlexible = flex;
m_hasContext = defc;
if (defc) {
m_defContext = new DefinitionContext(contain);
} else {
m_defContext = contain.getDefinitionContext();
}
}
/**
* Set the object context.
*
* @param objc object context
*/
public void setObjectContext(IContextObj objc) {
m_contextObject = objc;
}
/**
* Get the attribute children of this mapping.
*
* @return list of attribute children (null if none; should not
* be modified)
*/
public ArrayList getAttributes() {
return m_attributes;
}
/**
* Get the content children of this mapping.
*
* @return list of content children (should not be modified)
*/
public ArrayList getContents() {
return m_contents;
}
/**
* Add child component to nested structure. All components are initially
* assumed to contain content. When {@link #setLinkages} is called the
* components are checked to determine whether they actually supply
* attribute(s), content, or both.
*
* @param comp child component to be added to structure
*/
public void addComponent(IComponent comp) {
m_contents.add(comp);
}
/**
* Check if flexible unmarshalling.
*
* @return flexible flag
*/
public boolean isFlexible() {
return m_isFlexible;
}
//
// IContainer interface method definitions
public boolean isContentOrdered() {
return m_isOrdered;
}
public boolean hasNamespaces() {
return m_hasContext && m_defContext.hasNamespace();
}
public BindingDefinition getBindingRoot() {
return m_container.getBindingRoot();
}
public DefinitionContext getDefinitionContext() {
return m_defContext;
}
//
// IComponent interface method definitions
public boolean isOptional() {
// optional if and only if all child components are optional
if (m_attributes != null) {
for (int i = 0; i < m_attributes.size(); i++) {
if (!((IComponent)m_attributes.get(i)).isOptional()) {
return false;
}
}
}
for (int i = 0; i < m_contents.size(); i++) {
if (!((IComponent)m_contents.get(i)).isOptional()) {
return false;
}
}
return true;
}
public boolean hasContent() {
return m_contents.size() > 0;
}
public void genContentPresentTest(ContextMethodBuilder mb)
throws JiBXException {
if (m_contents.size() > 0) {
// if single possiblity just test it directly
int count = m_contents.size();
if (count == 1) {
((IComponent)m_contents.get(0)).genContentPresentTest(mb);
} else {
// generate code for chained test with branches to found exit
BranchWrapper[] tofound = new BranchWrapper[count];
for (int i = 0; i < count; i++) {
IComponent comp = (IComponent)m_contents.get(i);
comp.genContentPresentTest(mb);
tofound[i] = mb.appendIFNE(this);
}
// fall off end of loop to push "false" on stack and jump to end
mb.appendICONST_0();
BranchWrapper toend = mb.appendUnconditionalBranch(this);
// generate found target to push "true" on stack and continue
for (int i = 0; i < count; i++) {
mb.targetNext(tofound[i]);
}
mb.appendICONST_1();
mb.targetNext(toend);
}
} else {
throw new IllegalStateException
("Internal error - no content present");
}
}
public String getType() {
return m_contextObject.getBoundClass().getClassName();
}
public NameDefinition getWrapperName() {
if (m_contents.size() == 1) {
return ((IComponent)m_contents.get(0)).getWrapperName();
} else {
return null;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/ElementWrapper.java 0000644 0001750 0001750 00000056440 11153073226 025625 0 ustar twerner twerner /*
Copyright (c) 2003-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.apache.bcel.generic.Type;
import org.jibx.binding.classes.*;
import org.jibx.runtime.JiBXException;
/**
* Component decorator for element definition. This associates an element name
* with a component.
*
* @author Dennis M. Sosnoski
*/
public class ElementWrapper implements IComponent
{
//
// Constants and such related to code generation.
private static final String UNMARSHAL_PARSESTARTATTRIBUTES =
"org.jibx.runtime.impl.UnmarshallingContext.parseToStartTag";
private static final String UNMARSHAL_PARSESTARTNOATTRIBUTES =
"org.jibx.runtime.impl.UnmarshallingContext.parsePastStartTag";
private static final String UNMARSHAL_PARSEPASTSTART =
"org.jibx.runtime.impl.UnmarshallingContext.parsePastStartTag";
private static final String UNMARSHAL_PARSESTARTSIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;)V";
private static final String UNMARSHAL_PARSEENDMETHOD =
"org.jibx.runtime.impl.UnmarshallingContext.parsePastCurrentEndTag";
private static final String UNMARSHAL_PARSEENDSIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;)V";
private static final String UNMARSHAL_ISATMETHOD =
"org.jibx.runtime.IUnmarshallingContext.isAt";
private static final String UNMARSHAL_ISATSIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;)Z";
private static final String UNMARSHAL_SKIPELEMENTMETHOD =
"org.jibx.runtime.impl.UnmarshallingContext.parsePastElement";
private static final String UNMARSHAL_SKIPELEMENTSIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;)V";
private static final String MARSHAL_WRITESTARTNAMESPACES =
"org.jibx.runtime.impl.MarshallingContext.startTagNamespaces";
private static final String MARSHAL_STARTNAMESPACESSIGNATURE =
"(ILjava/lang/String;[I[Ljava/lang/String;)" +
"Lorg/jibx/runtime/impl/MarshallingContext;";
private static final String MARSHAL_WRITESTARTATTRIBUTES =
"org.jibx.runtime.impl.MarshallingContext.startTagAttributes";
private static final String MARSHAL_WRITESTARTNOATTRIBUTES =
"org.jibx.runtime.impl.MarshallingContext.startTag";
private static final String MARSHAL_WRITESTARTSIGNATURE =
"(ILjava/lang/String;)Lorg/jibx/runtime/impl/MarshallingContext;";
private static final String MARSHAL_CLOSESTARTCONTENT =
"org.jibx.runtime.impl.MarshallingContext.closeStartContent";
private static final String MARSHAL_CLOSESTARTEMPTY =
"org.jibx.runtime.impl.MarshallingContext.closeStartEmpty";
private static final String MARSHAL_CLOSESTARTSIGNATURE =
"()Lorg/jibx/runtime/impl/MarshallingContext;";
private static final String MARSHAL_WRITEENDMETHOD =
"org.jibx.runtime.impl.MarshallingContext.endTag";
private static final String MARSHAL_WRITEENDSIGNATURE =
"(ILjava/lang/String;)Lorg/jibx/runtime/impl/MarshallingContext;";
private static final String UNMARSHAL_PARSE_TO_START_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.parseToStartTag";
private static final String UNMARSHAL_PARSE_TO_START_SIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;)V";
protected static final String UNMARSHAL_ATTRIBUTE_BOOLEAN_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.attributeBoolean";
protected static final String UNMARSHAL_ATTRIBUTE_BOOLEAN_SIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;Z)Z";
private static final String UNMARSHAL_SKIP_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.skipElement";
private static final String UNMARSHAL_SKIP_SIGNATURE = "()V";
protected static final String MARSHAL_STARTTAG_ATTRIBUTES =
"org.jibx.runtime.impl.MarshallingContext.startTagAttributes";
protected static final String MARSHAL_STARTTAG_SIGNATURE =
"(ILjava/lang/String;)Lorg/jibx/runtime/impl/MarshallingContext;";
protected static final String MARSHAL_CLOSESTART_EMPTY =
"org.jibx.runtime.impl.MarshallingContext.closeStartEmpty";
protected static final String MARSHAL_CLOSESTART_EMPTY_SIGNATURE =
"()Lorg/jibx/runtime/impl/MarshallingContext;";
protected static final String MARSHAL_ATTRIBUTE =
"org.jibx.runtime.impl.MarshallingContext.attribute";
protected static final String MARSHAL_SIGNATURE =
"(ILjava/lang/String;Ljava/lang/String;)" +
"Lorg/jibx/runtime/impl/MarshallingContext;";
private static final String MARSHALLING_CONTEXT =
"org.jibx.runtime.impl.MarshallingContext";
private static final String UNMARSHALLING_CONTEXT =
"org.jibx.runtime.impl.UnmarshallingContext";
//
// Actual instance data.
/** Property value binding component. */
private final IComponent m_component;
/** Binding definition context. */
private final DefinitionContext m_defContext;
/** Element name information. */
private final NameDefinition m_name;
/** Flag for nillable element. */
private final boolean m_isNillable;
/** Flag for value from collection (TODO: fix this in update). */
private boolean m_directAccess;
/** Flag for optional ignored element (TODO: fix this in update). */
private boolean m_optionalIgnored;
/** Flag for optional normal element (TODO: fix this in update). */
private boolean m_optionalNormal;
/** Flag for optional structure object (TODO: fix this in update). */
private boolean m_structureObject;
/**
* Constructor.
*
* @param defc definition context for this component
* @param name element name definition
* @param wrap wrapped binding component (may be null, in the
* case of a throwaway component)
* @param nillable flag for nillable element
*/
public ElementWrapper(DefinitionContext defc, NameDefinition name,
IComponent wrap, boolean nillable) {
m_defContext = defc;
m_name = name;
m_component = wrap;
m_isNillable = nillable;
}
/**
* Set the direct access flag. This controls a variation in the code
* generation to handle values loaded from a collection.
*
* @param direct true if direct access from collection,
* false if not
*/
public void setDirect(boolean direct) {
m_directAccess = direct;
}
/**
* Set flag for an optional ignored element.
*
* @param opt true if optional ignored element,
* false if not
*/
public void setOptionalIgnored(boolean opt) {
m_optionalIgnored = opt;
}
/**
* Set flag for an optional structure object.
*
* @param opt true if optional structure object,
* false if not
*/
public void setStructureObject(boolean opt) {
m_structureObject = opt;
}
/**
* Set flag for an optional normal element.
*
* @param opt true if optional normal element,
* false if not
*/
public void setOptionalNormal(boolean opt) {
m_optionalNormal = opt;
}
//
// IComponent interface method definitions
public boolean isOptional() {
return m_optionalNormal || m_optionalIgnored;
}
public boolean hasAttribute() {
return false;
}
public void genAttrPresentTest(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no attributes from child element");
}
public void genAttributeUnmarshal(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no attributes from child element");
}
public void genAttributeMarshal(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no attributes from child element");
}
public boolean hasContent() {
return true;
}
public void genContentPresentTest(ContextMethodBuilder mb)
throws JiBXException {
// create call to unmarshalling context method with namespace and
// name, then return result directly
mb.loadContext();
m_name.genPushUriPair(mb);
mb.appendCallInterface(UNMARSHAL_ISATMETHOD, UNMARSHAL_ISATSIGNATURE);
}
public void genContentUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
// generate code to store null to property
PropertyDefinition prop = null;
if (m_component instanceof ComponentProperty) {
prop = ((ComponentProperty)m_component).getProperty();
}
// check for optional empty wrapper present
BranchWrapper ifmiss = null;
BranchTarget loop = null;
if (isOptional()) {
// set first pass indicator for setting presence flag, along with
// loop target for repeated checks (when skipping repeated element)
int first = -1;
if (prop != null && prop.hasFlag()) {
mb.appendICONST_1();
first = mb.addLocal("first", Type.BOOLEAN);
BranchWrapper tocheck = mb.appendUnconditionalBranch(this);
mb.initStackState(tocheck);
loop = mb.appendTargetLoadConstant(0);
mb.appendStoreLocal(first);
mb.targetNext(tocheck);
} else {
loop = mb.appendTargetNOP();
}
// check for element present, setting presence flag on first pass only
genContentPresentTest(mb);
if (prop != null && prop.hasFlag()) {
mb.appendLoadLocal(first);
BranchWrapper notfirst = mb.appendIFEQ(this);
mb.appendDUP();
mb.loadObject();
mb.appendSWAP();
prop.genFlag(mb);
mb.targetNext(notfirst);
}
ifmiss = mb.appendIFEQ(this);
} else if (prop != null && prop.hasFlag()) {
// required element, make sure it's present and set flag
mb.loadContext(UNMARSHALLING_CONTEXT);
m_name.genPushUriPair(mb);
mb.appendCallVirtual(UNMARSHAL_PARSE_TO_START_NAME,
UNMARSHAL_PARSE_TO_START_SIGNATURE);
mb.appendICONST_1();
prop.genFlag(mb);
}
BranchWrapper ifnil = null;
if (m_isNillable) {
// make sure we're at the element
mb.loadContext(UNMARSHALLING_CONTEXT);
m_name.genPushUriPair(mb);
mb.appendCallVirtual(UNMARSHAL_PARSE_TO_START_NAME,
UNMARSHAL_PARSE_TO_START_SIGNATURE);
// check for xsi:nil="true"
mb.loadContext(UNMARSHALLING_CONTEXT);
mb.appendLoadConstant("http://www.w3.org/2001/XMLSchema-instance");
mb.appendLoadConstant("nil");
mb.appendICONST_0();
mb.appendCallVirtual(UNMARSHAL_ATTRIBUTE_BOOLEAN_NAME,
UNMARSHAL_ATTRIBUTE_BOOLEAN_SIGNATURE);
BranchWrapper notnil = mb.appendIFEQ(this);
// skip past the element before jumping to end
mb.loadContext(UNMARSHALLING_CONTEXT);
mb.appendCallVirtual(UNMARSHAL_SKIP_NAME,
UNMARSHAL_SKIP_SIGNATURE);
ifnil = mb.appendUnconditionalBranch(this);
mb.targetNext(notnil);
}
// set up flags for controlling code generation paths
boolean attr = m_component != null && m_component.hasAttribute();
boolean cont = m_component != null && m_component.hasContent();
// load the unmarshalling context followed by the namespace URI and
// element name.
mb.loadContext(UNMARSHALLING_CONTEXT);
m_name.genPushUriPair(mb);
// check type of unmarshalling behavior required
if (attr) {
// unmarshal start tag with attribute(s)
mb.appendCallVirtual(UNMARSHAL_PARSESTARTATTRIBUTES,
UNMARSHAL_PARSESTARTSIGNATURE);
m_component.genAttributeUnmarshal(mb);
// generate code to parse past the start tag with another call
// to unmarshalling context
mb.loadContext(UNMARSHALLING_CONTEXT);
m_name.genPushUriPair(mb);
mb.appendCallVirtual(UNMARSHAL_PARSEPASTSTART,
UNMARSHAL_PARSESTARTSIGNATURE);
} else if (cont) {
// unmarshal start tag without attributes
mb.appendCallVirtual(UNMARSHAL_PARSESTARTNOATTRIBUTES,
UNMARSHAL_PARSESTARTSIGNATURE);
} else {
// unmarshal element discarding all content, then loop to check for
// repeat of element
mb.appendCallVirtual(UNMARSHAL_SKIPELEMENTMETHOD,
UNMARSHAL_SKIPELEMENTSIGNATURE);
if (loop != null && ifmiss != null) {
mb.appendUnconditionalBranch(this).setTarget(loop, mb);
mb.targetNext(ifmiss);
ifmiss = null;
mb.appendPOP();
mb.appendACONST_NULL();
}
}
// unmarshal child content
if (cont) {
m_component.genContentUnmarshal(mb);
}
// next add code to push context, namespace and name, and call
// method to parse past end tag
if (attr || cont) {
mb.loadContext(UNMARSHALLING_CONTEXT);
m_name.genPushUriPair(mb);
mb.appendCallVirtual(UNMARSHAL_PARSEENDMETHOD,
UNMARSHAL_PARSEENDSIGNATURE);
}
// check if need code to handle missing or nil element
if (ifmiss != null || ifnil != null) {
// handle branch conditions, jumping around code to set null
BranchWrapper toend = mb.appendUnconditionalBranch(this);
mb.targetNext(ifmiss);
mb.targetNext(ifnil);
// generate code to store null to property
if (m_component instanceof ComponentProperty) {
if (!prop.isImplicit()) {
mb.loadObject();
mb.appendACONST_NULL();
prop.genStore(mb);
} else {
mb.appendACONST_NULL();
}
} else {
mb.appendPOP();
mb.appendACONST_NULL();
}
mb.targetNext(toend);
}
}
public void genContentMarshal(ContextMethodBuilder mb)
throws JiBXException {
// nothing to be done if optional ignored element
if (!m_optionalIgnored) {
boolean noprop = m_directAccess ||
(!(m_component instanceof ComponentProperty) &&
!(m_component instanceof NestedStructure));
BranchWrapper ifmiss = null;
if (m_isNillable) {
// check for null object
BranchWrapper ifhit;
if (noprop) {
mb.appendDUP();
ifhit = mb.appendIFNONNULL(this);
mb.appendPOP();
} else {
PropertyDefinition prop =
((ComponentProperty)m_component).getProperty();
mb.loadObject();
prop.genLoad(mb);
ifhit = mb.appendIFNONNULL(this);
}
// generate empty element with xsi:nil="true"
mb.loadContext(MARSHALLING_CONTEXT);
m_name.genPushIndexPair(mb);
mb.appendCallVirtual(MARSHAL_STARTTAG_ATTRIBUTES,
MARSHAL_STARTTAG_SIGNATURE);
mb.appendLoadConstant(2);
mb.appendLoadConstant("nil");
mb.appendLoadConstant("true");
mb.appendCallVirtual(MARSHAL_ATTRIBUTE, MARSHAL_SIGNATURE);
mb.appendCallVirtual(MARSHAL_CLOSESTART_EMPTY,
MARSHAL_CLOSESTART_EMPTY_SIGNATURE);
mb.appendPOP();
ifmiss = mb.appendUnconditionalBranch(this);
mb.targetNext(ifhit);
}
// set up flags for controlling code generation paths
boolean attr = m_component != null && m_component.hasAttribute();
boolean cont = m_component != null && m_component.hasContent();
boolean needns = !m_structureObject && m_defContext.hasNamespace();
// duplicate object reference on stack if both attribute(s) and
// content
if (attr && cont && noprop) {
mb.appendDUP();
}
// load the context followed by namespace index and element name
mb.loadContext(MARSHALLING_CONTEXT);
m_name.genPushIndexPair(mb);
// check type of marshalling behavior required
if (attr || needns) {
// check for namespace definition required
if (needns) {
// marshal start tag with namespace(s)
m_defContext.genLoadNamespaces(mb);
mb.appendCallVirtual(MARSHAL_WRITESTARTNAMESPACES,
MARSHAL_STARTNAMESPACESSIGNATURE);
} else {
// marshal start tag with attribute(s)
mb.appendCallVirtual(MARSHAL_WRITESTARTATTRIBUTES,
MARSHAL_WRITESTARTSIGNATURE);
}
// handle attributes other than namespace declarations
if (attr) {
if (noprop) {
// discard marshalling context from stack before call
mb.appendPOP();
m_component.genAttributeMarshal(mb);
mb.loadContext(MARSHALLING_CONTEXT);
} else {
m_component.genAttributeMarshal(mb);
}
}
// generate code to close the start tag with another call
// to marshalling context
if (cont) {
mb.appendCallVirtual(MARSHAL_CLOSESTARTCONTENT,
MARSHAL_CLOSESTARTSIGNATURE);
} else {
mb.appendCallVirtual(MARSHAL_CLOSESTARTEMPTY,
MARSHAL_CLOSESTARTSIGNATURE);
}
} else if (cont) {
// marshal start tag without attributes
mb.appendCallVirtual(MARSHAL_WRITESTARTNOATTRIBUTES,
MARSHAL_WRITESTARTSIGNATURE);
} else {
// marshal empty tag
mb.appendCallVirtual(MARSHAL_WRITESTARTATTRIBUTES,
MARSHAL_WRITESTARTSIGNATURE);
mb.appendCallVirtual(MARSHAL_CLOSESTARTEMPTY,
MARSHAL_CLOSESTARTSIGNATURE);
}
// handle child content if present
if (cont) {
if (noprop) {
// discard marshalling context from stack before call
mb.appendPOP();
m_component.genContentMarshal(mb);
mb.loadContext(MARSHALLING_CONTEXT);
} else {
m_component.genContentMarshal(mb);
}
// write the element close tag
m_name.genPushIndexPair(mb);
mb.appendCallVirtual(MARSHAL_WRITEENDMETHOD,
MARSHAL_WRITEENDSIGNATURE);
}
mb.appendPOP();
mb.targetNext(ifmiss);
}
}
public void genNewInstance(ContextMethodBuilder mb) throws JiBXException {
if (m_component == null) {
throw new IllegalStateException
("Internal error - no wrapped component");
} else {
m_component.genNewInstance(mb);
}
}
public String getType() {
if (m_component == null) {
throw new IllegalStateException
("Internal error - no wrapped component");
} else {
return m_component.getType();
}
}
public boolean hasId() {
if (m_component == null) {
return false;
} else {
return m_component.hasId();
}
}
public void genLoadId(ContextMethodBuilder mb) throws JiBXException {
if (m_component == null) {
throw new IllegalStateException
("Internal error - no wrapped component");
} else {
m_component.genLoadId(mb);
}
}
public NameDefinition getWrapperName() {
return m_name;
}
public void setLinkages() throws JiBXException {
m_name.fixNamespace(m_defContext);
if (m_component != null) {
m_component.setLinkages();
}
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.println(toString());
if (m_component != null) {
m_component.print(depth+1);
}
}
public String toString() {
StringBuffer buff = new StringBuffer("element wrapper");
if (m_name != null) {
buff.append(' ');
buff.append(m_name.toString());
}
if (m_directAccess) {
buff.append(" direct");
}
if (m_optionalIgnored) {
buff.append(" optional ignored");
}
if (m_optionalNormal) {
buff.append(" optional");
}
if (m_structureObject) {
buff.append(" structure object");
}
return buff.toString();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/StringConversion.java 0000644 0001750 0001750 00000046326 11262211332 026202 0 ustar twerner twerner /*
Copyright (c) 2003-2009, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.apache.bcel.classfile.Utility;
import org.jibx.binding.classes.*;
import org.jibx.runtime.JiBXException;
/**
* String conversion handling. Defines serialization handling for converting
* to and from a String value. This uses an inheritance approach,
* where each serialization definition is initialized based on the handling
* set for the containing definition of the same (or parent class) type.
*
* @author Dennis M. Sosnoski
*/
public abstract class StringConversion
{
//
// Constants for code generation.
protected static final String UNMARSHAL_OPT_ATTRIBUTE =
"org.jibx.runtime.impl.UnmarshallingContext.attributeText";
protected static final String UNMARSHAL_OPT_ELEMENT =
"org.jibx.runtime.impl.UnmarshallingContext.parseElementText";
protected static final String UNMARSHAL_OPT_SIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)" +
"Ljava/lang/String;";
protected static final String UNMARSHAL_REQ_ATTRIBUTE =
"org.jibx.runtime.impl.UnmarshallingContext.attributeText";
protected static final String UNMARSHAL_REQ_ELEMENT =
"org.jibx.runtime.impl.UnmarshallingContext.parseElementText";
protected static final String UNMARSHAL_REQ_SIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;";
protected static final String MARSHAL_ATTRIBUTE =
"org.jibx.runtime.impl.MarshallingContext.attribute";
protected static final String MARSHAL_ELEMENT =
"org.jibx.runtime.impl.MarshallingContext.element";
protected static final String MARSHAL_SIGNATURE =
"(ILjava/lang/String;Ljava/lang/String;)" +
"Lorg/jibx/runtime/impl/MarshallingContext;";
protected static final String COMPARE_OBJECTS_METHOD =
"org.jibx.runtime.Utility.isEqual";
protected static final String COMPARE_OBJECTS_SIGNATURE =
"(Ljava/lang/Object;Ljava/lang/Object;)Z";
protected static final String[] WHITESPACE_CONVERT_SIGNATURES =
{
"(Ljava/lang/String;)Ljava/lang/String;"
};
protected static final String[] DESERIALIZER_SIGNATURES =
{
"(Ljava/lang/String;)",
"(Ljava/lang/String;Lorg/jibx/runtime/IUnmarshallingContext;)"
};
// values used for name in marshalling; must be 1 or 2
public static final int MARSHAL_NAME_VALUES = 2;
//
// Actual instance data
/** Default value used for this type (wrapper for primitives, otherwise
String or null). */
protected Object m_default;
/** Serializer method information. */
protected ClassItem m_serializer;
/** Whitespace conversion method information. */
protected ClassItem m_converter;
/** Deserializer method information. */
protected ClassItem m_deserializer;
/** Fully qualified name of class handled by conversion. */
protected String m_typeName;
/** Signature of class handled by conversion. */
protected String m_typeSignature;
/**
* Constructor. This internal form only initializes the type information.
*
* @param type fully qualified name of class handled by conversion
*/
private StringConversion(String type) {
m_typeName = type;
m_typeSignature = Utility.getSignature(type);
}
/**
* Constructor. Initializes conversion handling based on the supplied
* inherited handling.
*
* @param type fully qualified name of class handled by conversion
* @param inherit conversion information inherited by this conversion
*/
protected StringConversion(String type, StringConversion inherit) {
this(type);
m_default = inherit.m_default;
m_serializer = inherit.m_serializer;
m_converter = inherit.m_converter;
m_deserializer = inherit.m_deserializer;
}
/**
* Constructor. Initializes conversion handling based on argument values.
* This form is only used for constructing the default set of conversions.
* Because of this, it throws an unchecked exception on error.
*
* @param dflt default value object (wrapped value for primitive types,
* otherwise String)
* @param ser fully qualified name of serialization method
* (null if none)
* @param conv fully qualified name of whitespace conversion method
* (null if none)
* @param deser fully qualified name of deserialization method
* (null if none)
* @param type fully qualified name of class handled by conversion
*/
/*package*/ StringConversion(Object dflt, String ser, String conv,
String deser, String type) {
this(type);
m_default = dflt;
try {
if (ser != null) {
setSerializer(ser, false);
}
if (conv != null) {
setWhitespaceConverter(conv);
}
if (deser != null) {
setDeserializer(deser);
}
} catch (JiBXException ex) {
throw new IllegalArgumentException(ex.getMessage());
}
}
/**
* Get name of type handled by this conversion.
*
* @return fully qualified class name of type handled by conversion
*/
public String getTypeName() {
return m_typeName;
}
/**
* Generate code to convert String representation. The
* code generated by this method assumes that the String
* value has already been pushed on the stack. It consumes this and
* leaves the converted value on the stack.
*
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public abstract void genFromText(ContextMethodBuilder mb)
throws JiBXException;
/**
* Generate code to parse and convert optional attribute or element. This
* abstract base class method must be implemented by every subclass. The
* code generated by this method assumes that the unmarshalling context
* and name information for the attribute or element have already
* been pushed on the stack. It consumes these and leaves the converted
* value (or converted default value, if the item itself is missing) on
* the stack.
*
* @param attr item is an attribute (vs element) flag
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public abstract void genParseOptional(boolean attr, ContextMethodBuilder mb)
throws JiBXException;
/**
* Generate code to parse and convert required attribute or element. This
* abstract base class method must be implemented by every subclass. The
* code generated by this method assumes that the unmarshalling context and
* name information for the attribute or element have already been pushed
* on the stack. It consumes these and leaves the converted value on the
* stack.
*
* @param attr item is an attribute (vs element) flag
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public abstract void genParseRequired(boolean attr, ContextMethodBuilder mb)
throws JiBXException;
/**
* Generate code to write String value to generated document.
* The code generated by this method assumes that the marshalling context,
* the name information, and the actual value to be converted have already
* been pushed on the stack. It consumes these, leaving the marshalling
* context on the stack.
*
* @param attr item is an attribute (vs element) flag
* @param mb method builder
*/
public void genWriteText(boolean attr, ContextMethodBuilder mb) {
// append code to call the appropriate generic marshalling context
// String method
String name = attr ? MARSHAL_ATTRIBUTE : MARSHAL_ELEMENT;
mb.appendCallVirtual(name, MARSHAL_SIGNATURE);
}
/**
* Generate code to pop values from stack.
*
* @param count number of values to be popped
* @param mb method builder
*/
public void genPopValues(int count, ContextMethodBuilder mb) {
while (--count >= 0) {
if (mb.isStackTopLong()) {
mb.appendPOP2();
} else {
mb.appendPOP();
}
}
}
/**
* Generate code to check if an optional value is not equal to the default.
* This abstract base class method must be implemented by every subclass.
* The code generated by this method assumes that the actual value to be
* converted has already been pushed on the stack. It consumes this,
* leaving the converted text reference on the stack if it's not equal to
* the default value.
*
* @param type fully qualified class name for value on stack
* @param mb method builder
* @param extra count of extra words to be popped from stack if missing
* @return handle for branch taken when value is equal to the default
* (target must be set by caller)
* @throws JiBXException if error in configuration
*/
protected abstract BranchWrapper genToOptionalText(String type,
ContextMethodBuilder mb, int extra) throws JiBXException;
/**
* Generate code to convert value to a String. The code
* generated by this method assumes that the actual value to be converted
* has already been pushed on the stack. It consumes this, leaving the
* converted text reference on the stack.
*
* @param type fully qualified class name for value on stack
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public void genToText(String type, ContextMethodBuilder mb)
throws JiBXException {
// check if a serializer is used for this type
if (m_serializer != null) {
// just generate call to the serializer (adding any checked
// exceptions thrown by the serializer to the list needing
// handling)
if (!isPrimitive()) {
mb.appendCreateCast(type, m_serializer.getArgumentType(0));
}
mb.addMethodExceptions(m_serializer);
if (m_serializer.getArgumentCount() > 1) {
mb.loadContext();
}
mb.appendCall(m_serializer);
} else {
// make sure this is a string
mb.appendCreateCast(type, "java.lang.String");
}
}
/**
* Generate code to convert and write optional value to generated document.
* The generated code first tests if the value is the same as the supplied
* default, and if so skips writing. The code assumes that the marshalling
* context, the name information, and the actual value to be converted have
* already been pushed on the stack. It consumes these, leaving only the
* marshalling context on the stack.
*
* @param attr item is an attribute (vs element) flag
* @param type fully qualified class name for value on stack
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public void genWriteOptional(boolean attr, String type,
ContextMethodBuilder mb) throws JiBXException {
// start with code to convert value to String, if it's not equal to the
// default value
BranchWrapper toend = genToOptionalText(type, mb, MARSHAL_NAME_VALUES);
// next use standard write code, followed by targeting branch
genWriteText(attr, mb);
if (toend != null) {
mb.targetNext(toend);
}
}
/**
* Generate code to convert and write required value to generated document.
* The code generated by this method assumes that the marshalling context,
* the name information, and the actual value to be converted have already
* been pushed on the stack. It consumes these, leaving the returned
* marshalling context on the stack.
*
* @param attr item is an attribute (vs element) flag
* @param type fully qualified class name for value on stack
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public void genWriteRequired(boolean attr, String type,
ContextMethodBuilder mb) throws JiBXException {
// generate code to convert to text, followed by code to marshal text
genToText(type, mb);
genWriteText(attr, mb);
}
/**
* Check if the type handled by this conversion is of a primitive type.
*
* @return true if a primitive type, false if an
* object type
*/
public abstract boolean isPrimitive();
/**
* Set serializer for conversion. This finds the named static method and
* sets it as the serializer to be used for this conversion. The serializer
* method is expected to take a single argument of either the handled
* type or a superclass or interface of the handled type, and to return a
* String result.
*
* @param ser fully qualified class and method name of serializer
* @param variant allow variants of the specified type
* @throws JiBXException if serializer not found or not usable
*/
protected void setSerializer(String ser, boolean variant) throws JiBXException {
// build all possible signature variations
String[] tsigs;
if (variant) {
tsigs = ClassItem.getSignatureVariants(m_typeName);
} else {
tsigs = new String[] { Utility.getSignature(m_typeName) };
}
String[] msigs = new String[tsigs.length*2];
for (int i = 0; i < tsigs.length; i++) {
msigs[i*2] = "(" + tsigs[i] + ")Ljava/lang/String;";
msigs[i*2+1] = "(" + tsigs[i] +
"Lorg/jibx/runtime/IMarshallingContext;)Ljava/lang/String;";
}
// find a matching static method
ClassItem method = ClassItem.findStaticMethod(ser, msigs);
// report error if method not found
if (method == null) {
throw new JiBXException("Serializer " + ser + " not found");
} else {
m_serializer = method;
}
}
/**
* Set whitespace converter for conversion. This finds the named static
* method and sets it as the whitespace converter to be used for this
* conversion. The whitespace converter method is expected to take a
* single argument of type String, and to return the same.
*
* @param wsconv fully qualified class and method name of whitespace
* converter
* @throws JiBXException if whitespace converter not found or not usable
*/
protected void setWhitespaceConverter(String wsconv) throws JiBXException {
// find a matching static method
m_converter =
ClassItem.findStaticMethod(wsconv, WHITESPACE_CONVERT_SIGNATURES);
// report error if method not found or incompatible
if (m_converter == null) {
throw new JiBXException("Whitespace converter " + wsconv + " not found");
}
}
/**
* Set deserializer for conversion. This finds the named static method and
* sets it as the deserializer to be used for this conversion. The
* deserializer method is expected to take a single argument of type
* String, and to return a value of the handled type or a
* subtype of that type.
*
* @param deser fully qualified class and method name of deserializer
* @throws JiBXException if deserializer not found or not usable
*/
protected void setDeserializer(String deser) throws JiBXException {
// find a matching static method
ClassItem method =
ClassItem.findStaticMethod(deser, DESERIALIZER_SIGNATURES);
// report error if method not found or incompatible
if (method == null) {
throw new JiBXException("Deserializer " + deser + " not found");
} else if (ClassItem.isAssignable(method.getTypeName(), m_typeName)) {
m_deserializer = method;
} else {
throw new JiBXException("Deserializer " + deser +
" returns wrong type");
}
}
/**
* Convert text representation into default value object. Each subclass
* must implement this with the appropriate conversion handling.
*
* @param text value representation to be converted
* @return converted default value object
* @throws JiBXException on conversion error
*/
protected abstract Object convertDefault(String text) throws JiBXException;
/**
* Derive from existing formatting information. This abstract base class
* method must be implemented by every subclass. It allows constructing
* a new instance from an existing format of the same or an ancestor
* type, with the properties of the existing format copied to the new
* instance except where overridden by the supplied values.
*
* @param type fully qualified name of class handled by conversion
* (null if inherited)
* @param ser fully qualified name of serialization method
* (null if inherited)
* @param conv fully qualified name of whitespace conversion method
* (null if inherited)
* @param dser fully qualified name of deserialization method
* (null if inherited)
* @param dflt default value text (null if inherited)
* @return new instance initialized from existing one
* @throws JiBXException if error in configuration information
*/
public abstract StringConversion derive(String type, String ser,
String conv, String dser, String dflt) throws JiBXException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/LinkableBase.java 0000644 0001750 0001750 00000007117 10767272750 025221 0 ustar twerner twerner /*
Copyright (c) 2003-2008, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.jibx.runtime.JiBXException;
/**
* Base class for components that can be linked from multiple locations within
* the binding definition structure. The implemented basic behavior is a simple
* pass-through component, with the addition of recursion checking during the
* linking phase.
*
* @author Dennis M. Sosnoski
*/
public abstract class LinkableBase extends PassThroughComponent
{
/** Flag for linkage in progress. */
private boolean m_isLinking;
/** Flag for linkage complete. */
private boolean m_isLinked;
/**
* No argument constructor. This requires the component to be set later,
* using the {@link
* org.jibx.binding.def.PassThroughComponent#setWrappedComponent} method.
*/
protected LinkableBase() {}
/**
* Constructor.
*
* @param wrap wrapped binding component
*/
public LinkableBase(IComponent wrap) {
super(wrap);
}
/**
* Handler for recursion. If recursion is found during linking this method
* will be called. The base class implementation does nothing, but may be
* overridden by subclases to implement the appropriate behavior.
*/
protected void handleRecursion() {}
/**
* Check if linkage processing for this component is complete.
*
* @return true if complete, false if not
*/
protected boolean isLinked() {
return m_isLinked;
}
//
// IComponent interface method definitions
// subclasses should call the base class implementation if they override
// this method
public void setLinkages() throws JiBXException {
if (m_isLinking) {
handleRecursion();
} else {
if (!m_isLinked) {
m_isLinking = true;
m_component.setLinkages();
m_isLinking = false;
m_isLinked = true;
}
}
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.println("linkable wrapper");
m_component.print(depth+1);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/MappingReference.java 0000644 0001750 0001750 00000023364 11046560546 026113 0 ustar twerner twerner /*
Copyright (c) 2003-2008, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import java.util.ArrayList;
import org.jibx.binding.classes.ContextMethodBuilder;
import org.jibx.runtime.JiBXException;
/**
* Reference to a mapping definition. This is used as a placeholder when
* building the component structure of a binding definition. It's necessary
* because the referenced mapping may not have been parsed yet. During the
* linkage phase that follows parsing this looks up the appropriate mapping
* definition and sets up the corresponding component structure. Thereafter it
* operates as a simple pass-through wrapper for the top child component.
*
* @author Dennis M. Sosnoski
*/
public class MappingReference extends PassThroughComponent
{
/** Containing binding definition structure. */
private final IContainer m_container;
/** Property definition. */
private final PropertyDefinition m_property;
/** Flag for nillable element. */
private final boolean m_isNillable;
/** Fully qualified name of mapped type. */
private String m_type;
/** Ordinary name of type for abstract mapping. */
private String m_referenceText;
/** Qualified name of type for abstract mapping. */
private String m_referenceQName;
/** Context object. */
private final IContextObj m_contextObject;
/** Name from reference (only allowed with abstract mappings) */
private final NameDefinition m_name;
/** Synthetic reference added to empty collection flag */
private final boolean m_isSynthetic;
/** Referenced mapping. */
private IMapping m_mapping;
/** Generated wrapped component, used when checking for both attributes
and elements present. */
private IComponent m_wrappedReference;
/**
* Constructor from property and type.
*
* @param contain containing binding definition structure
* @param prop property definition
* @param type fully qualified name of mapped type
* @param reftext ordinary text name for abstract mapping reference
* (null if not specified)
* @param refqname qualified type name for abstract mapping reference
* (null if not specified)
* @param objc current object context
* @param name reference name definition (only allowed with abstract
* mappings)
* @param synth sythentic reference added to empty collection flag
* @param nillable flag for nillable element
*/
public MappingReference(IContainer contain, PropertyDefinition prop,
String type, String reftext, String refqname, IContextObj objc,
NameDefinition name, boolean synth, boolean nillable) {
super();
m_container = contain;
m_property = prop;
m_type = type;
m_referenceText = reftext;
m_referenceQName = refqname;
m_contextObject = objc;
m_name = name;
m_isSynthetic = synth;
m_isNillable = nillable;
}
public IMapping getMapping() {
return m_mapping;
}
//
// IComponent interface method definitions (overrides of defaults)
public boolean isOptional() {
return m_property.isOptional();
}
public String getType() {
return m_type;
}
public void setLinkages() throws JiBXException {
// find the mapping being used
DefinitionContext defc = m_container.getDefinitionContext();
IMapping mdef = null;
if (m_referenceText != null) {
mdef = defc.getClassMapping(m_referenceText);
if (mdef == null) {
mdef = defc.getClassMapping(m_referenceQName);
}
}
if (mdef == null) {
mdef = defc.getClassMapping(m_type);
}
m_mapping = mdef;
IComponent wrap = null;
PropertyDefinition prop = m_property;
if (mdef == null) {
// generate generic mapping to unknown type
if (m_name != null) {
throw new JiBXException
("Name not allowed for generic mapping of type " + m_type);
}
wrap = new DirectGeneric(m_container, m_type, prop);
} else if (m_isSynthetic && mdef.isAbstract() && !mdef.isBase()) {
// collection reference to abstract non-base mapping as generic
wrap = new DirectGeneric(m_container, m_type, prop);
} else {
// check for reference from collection
if (prop.isImplicit()) {
prop.setOptional(false);
}
// add mapping namespaces to context (only if no element on mapping)
if (mdef.getName() == null) {
mdef.setLinkages();
ArrayList nss = mdef.getNamespaces();
if (nss != null) {
for (int i = 0; i < nss.size(); i++) {
defc.addImpliedNamespace((NamespaceDefinition)nss.get(i));
}
}
}
// generate wrapped component for all calls
String type = mdef.getBoundType();
if (prop.getTypeName() == null) {
prop = new PropertyDefinition(type, m_contextObject,
prop.isOptional());
}
if (m_name == null) {
wrap = mdef.buildRef(m_container, m_contextObject,
prop.getTypeName(), prop);
} else {
// force property required for internal structure
PropertyDefinition propcopy = new PropertyDefinition(prop);
propcopy.setOptional(false);
wrap = mdef.buildRef(m_container, m_contextObject,
prop.getTypeName(), propcopy);
m_wrappedReference = wrap;
if (mdef.getName() == null) {
// create the replacement components
IComponent icomp = wrap;
wrap = new ElementWrapper(defc, m_name, icomp, m_isNillable);
if (prop.isImplicit()) {
((ElementWrapper)wrap).setDirect(true);
}
if (prop.isOptional()) {
// make element optional
if (icomp instanceof ComponentProperty) {
((ComponentProperty)icomp).setSkipping(true);
}
((ElementWrapper)wrap).setOptionalNormal(true);
((ElementWrapper)wrap).setStructureObject(true);
((ElementWrapper)wrap).setDirect(true);
wrap = new OptionalStructureWrapper(wrap, prop,
true);
}
} else {
throw new JiBXException
("Name not allowed for reference to mapping of type " +
type + ", which already defines a name");
}
}
// set type based on mapping
m_type = mdef.getReferenceType();
}
// link actual component into structure
setWrappedComponent(wrap);
super.setLinkages();
}
/**
* Patch the generated code to remove the unmarshalled object when it's a
* "this" reference with both elements and attributes.
*
* @param mb
* @throws JiBXException
*/
public void genContentUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
super.genContentUnmarshal(mb);
// check for unmarshalling fix needed
if (m_wrappedReference != null && m_property.isThis() &&
m_wrappedReference.hasAttribute() &&
m_wrappedReference.hasContent()) {
mb.appendPOP();
}
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.print("mapping reference to " +
((m_referenceText == null) ? m_type : m_referenceText));
if (m_property != null) {
System.out.print(" using " + m_property.toString());
}
System.out.println();
if (m_component != null) {
m_component.print(depth+1);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/BindingBuilder.java 0000644 0001750 0001750 00000303707 11334745100 025553 0 ustar twerner twerner /*
Copyright (c) 2003-2010, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashSet;
import org.apache.bcel.Constants;
import org.jibx.binding.classes.BoundClass;
import org.jibx.binding.classes.BranchTarget;
import org.jibx.binding.classes.BranchWrapper;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.ClassItem;
import org.jibx.binding.classes.ExceptionMethodBuilder;
import org.jibx.binding.classes.MethodBuilder;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.runtime.Utility;
import org.jibx.runtime.impl.StringIntHashMap;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.util.ClasspathUrlExtender;
/**
* Binding definition builder. This processes the binding definition file to
* generate the code generation structure.
*
* @author Dennis M. Sosnoski
*/
public abstract class BindingBuilder
{
/** Element namespace used for binding definition file. */
private static final String URI_ELEMENTS = null;
/** Attribute namespace used for binding definition file. */
private static final String URI_ATTRIBUTES = null;
/* Common style attribute. */
private static final String COMMON_STYLE = "value-style";
/* Common linkage attributes. */
private static final String COMMON_AUTOLINK = "auto-link";
private static final String COMMON_ACCESSLEVEL = "access-level";
private static final String COMMON_STRIPPREFIX = "strip-prefix";
private static final String COMMON_STRIPSUFFIX = "strip-suffix";
private static final String COMMON_NAMESTYLE = "name-style";
/* Common name attributes. */
private static final String COMMON_NAME = "name";
private static final String COMMON_NAMESPACE = "ns";
/* Common object attributes. */
private static final String COMMON_FACTORY = "factory";
private static final String COMMON_PRESET = "pre-set";
private static final String COMMON_POSTSET = "post-set";
private static final String COMMON_PREGET = "pre-get";
private static final String COMMON_MARSHALLER = "marshaller";
private static final String COMMON_UNMARSHALLER = "unmarshaller";
private static final String COMMON_CREATETYPE = "create-type";
/* Common property attributes. */
private static final String COMMON_FIELD = "field";
private static final String COMMON_TYPE = "type";
private static final String COMMON_USAGE = "usage";
private static final String COMMON_TESTMETHOD = "test-method";
private static final String COMMON_GETMETHOD = "get-method";
private static final String COMMON_SETMETHOD = "set-method";
private static final String COMMON_FLAGMETHOD = "flag-method";
/* Common string attributes. */
private static final String COMMON_DEFAULT = "default";
private static final String COMMON_SERIALIZER = "serializer";
private static final String COMMON_WHITESPACE = "whitespace";
private static final String COMMON_DESERIALIZER = "deserializer";
private static final String COMMON_ENUMVALUEMETHOD = "enum-value-method";
/* Common label attributes. */
private static final String COMMON_LABEL = "label";
private static final String COMMON_USING = "using";
/* Common ordered and choice attributes. */
private static final String COMMON_ORDERED = "ordered";
private static final String COMMON_CHOICE = "choice";
private static final String COMMON_FLEXIBLE = "flexible";
private static final String COMMON_DUPLICATES = "allow-repeats";
/* Common nillable attribute. */
private static final String COMMON_NILLABLE = "nillable";
/** Definitions for "binding" element use "BINDING" prefix. */
private static final String BINDING_ELEMENT = "binding";
private static final String BINDING_NAME = "name";
private static final String BINDING_DIRECTION = "direction";
private static final String BINDING_GLOBALID = "global-id";
private static final String BINDING_FORWARDS = "forwards";
private static final String BINDING_PACKAGE = "package";
private static final String BINDING_TRACKING = "track-source";
private static final String BINDING_FORCE = "force-classes";
private static final String BINDING_ADD = "add-constructors";
private static final String BINDING_TRIM = "trim-whitespace";
private static final String BINDING_MAJORVER = "major-version";
private static final String BINDING_MINORVER = "minor-version";
// also COMMON_STYLE, and linkage group
/** Definitions for "namespace" element use "NAMESPACE" prefix. */
private static final String NAMESPACE_ELEMENT = "namespace";
private static final String NAMESPACE_URI = "uri";
private static final String NAMESPACE_PREFIX = "prefix";
private static final String NAMESPACE_DEFAULT = "default";
/** Definitions for "format" element use "FORMAT" prefix. */
private static final String FORMAT_ELEMENT = "format";
private static final String FORMAT_NAME = "label";
private static final String FORMAT_TYPE = "type";
// also string group
/** Definitions for "mapping" element use "MAPPING" prefix. */
private static final String MAPPING_ELEMENT = "mapping";
private static final String MAPPING_CLASS = "class";
private static final String MAPPING_ABSTRACT = "abstract";
private static final String MAPPING_EXTENDS = "extends";
private static final String MAPPING_TYPENAME = "type-name";
// also COMMON_STYLE, name, object, ordered, and linkage groups
/** Definitions for "value" element use "VALUE" prefix. */
private static final String VALUE_ELEMENT = "value";
private static final String VALUE_STYLE = "style";
private static final String VALUE_FORMAT = "format";
private static final String VALUE_CONSTANT = "constant";
private static final String VALUE_IDENT = "ident";
// also name, property, and string groups
/** Definitions for "structure" element use "STRUCTURE" prefix. */
private static final String STRUCTURE_ELEMENT = "structure";
private static final String STRUCTURE_MAPAS = "map-as";
// also COMMON_STYLE, name, object, ordered, property, and label groups
/** Definitions for "collection" element use "COLLECTION" prefix. */
private static final String COLLECTION_ELEMENT = "collection";
private static final String COLLECTION_LOADMETHOD = "load-method";
private static final String COLLECTION_SIZEMETHOD = "size-method";
private static final String COLLECTION_STOREMETHOD = "store-method";
private static final String COLLECTION_ADDMETHOD = "add-method";
private static final String COLLECTION_ITERMETHOD = "iter-method";
private static final String COLLECTION_ITEMTYPE = "item-type";
// also COMMON_STYLE, name, ordered, property, and label groups
/** Definitions for "include" element use "INCLUDE" prefix. */
private static final String INCLUDE_ELEMENT = "include";
private static final String INCLUDE_PATH = "path";
private static final String INCLUDE_PRECOMPILED = "precompiled";
//
// Value style enumeration.
private static final String[] VALUE_STYLE_NAMES =
{
"attribute", "cdata", "element", "text"
};
private static final int[] VALUE_STYLE_NUMS =
{
ValueChild.ATTRIBUTE_STYLE,
ValueChild.CDATA_STYLE,
ValueChild.ELEMENT_STYLE,
ValueChild.TEXT_STYLE
};
private static final String[] CONTAINING_STYLE_NAMES =
{
"attribute", "element"
};
private static final int[] CONTAINING_STYLE_NUMS =
{
ValueChild.ATTRIBUTE_STYLE,
ValueChild.ELEMENT_STYLE
};
//
// Enumeration for auto-link types.
/*package*/ static final int LINK_NONE = 0;
/*package*/ static final int LINK_FIELDS = 1;
/*package*/ static final int LINK_METHODS = 2;
private static final String[] AUTO_LINK_NAMES =
{
"fields", "none", "methods"
};
private static final int[] AUTO_LINK_NUMS =
{
LINK_FIELDS, LINK_NONE, LINK_METHODS
};
//
// Enumeration for access level.
/*package*/ static final int ACC_PRIVATE = 0;
/*package*/ static final int ACC_PACKAGE = 1;
/*package*/ static final int ACC_PROTECTED = 2;
/*package*/ static final int ACC_PUBLIC = 3;
private static final String[] ACCESS_LEVEL_NAMES =
{
"package", "private", "protected", "public"
};
private static final int[] ACCESS_LEVEL_NUMS =
{
ACC_PACKAGE, ACC_PRIVATE, ACC_PROTECTED, ACC_PUBLIC
};
//
// Enumeration for name generation styles.
/*package*/ static final int NAME_HYPHENS = 0;
/*package*/ static final int NAME_MIXED = 1;
private static final String[] NAME_GENERATE_NAMES =
{
"hyphens", "mixed-case"
};
private static final int[] NAME_GENERATE_NUMS =
{
NAME_HYPHENS, NAME_MIXED
};
//
// Attributes that imply a component object
private static final String[] COMPONENT_OBJECT_NAMESPACES =
{
URI_ATTRIBUTES,
URI_ATTRIBUTES,
URI_ATTRIBUTES,
URI_ATTRIBUTES
};
private static final String[] COMPONENT_OBJECT_NAMES =
{
COMMON_FACTORY,
COMMON_PRESET,
COMMON_POSTSET,
COMMON_PREGET
};
//
// Enumeration for namespace usage.
private static final String[] NAMESPACEACCESS_NAMES =
{
"all", "attributes", "elements", "none"
};
private static final int[] NAMESPACEACCESS_NUMS =
{
NamespaceDefinition.ALLDEFAULT_USAGE,
NamespaceDefinition.ATTRIBUTES_USAGE,
NamespaceDefinition.ELEMENTS_USAGE,
NamespaceDefinition.NODEFAULT_USAGE
};
//
// Ident type enumeration.
private static final String[] IDENTTYPE_NAMES =
{
"auto", "def", "direct", "ref"
};
private static final int[] IDENTTYPE_NUMS =
{
ValueChild.AUTO_IDENT,
ValueChild.DEF_IDENT,
ValueChild.DIRECT_IDENT,
ValueChild.REF_IDENT
};
//
// Binding direction enumeration.
private static final int DIRECTION_INPUT = 0;
private static final int DIRECTION_OUTPUT = 1;
private static final int DIRECTION_BOTH = 2;
private static final String[] BINDINGDIR_NAMES =
{
"both", "input", "output"
};
private static final int[] BINDINGDIR_NUMS =
{
DIRECTION_BOTH,
DIRECTION_INPUT,
DIRECTION_OUTPUT
};
//
// Constants for property usage values
private static final String USAGE_OPTIONAL = "optional";
private static final String USAGE_REQUIRED = "required";
//
// Checking and code generation constants
private static final String UNMARSHALLER_INTERFACE =
"org.jibx.runtime.IUnmarshaller";
private static final String MARSHALLER_INTERFACE =
"org.jibx.runtime.IMarshaller";
private static final String UNMARSHALLER_INTERFACETYPE =
"Lorg/jibx/runtime/IUnmarshaller;";
private static final String MARSHALLER_INTERFACETYPE =
"Lorg/jibx/runtime/IMarshaller;";
private static final String CUSTOM_ENUM_SERIALIZER_NAME =
"_jibx_serialize";
private static final String CUSTOM_ENUM_DESERIALIZER_NAME =
"_jibx_deserialize";
/**
* Check if attributes supply a name definition.
*
* @param ctx unmarshalling context information
* @return true if attributes define a name,
* false if not
*/
private static boolean isNamePresent(UnmarshallingContext ctx) {
return ctx.attributeText(URI_ATTRIBUTES, COMMON_NAME, null) != null;
}
/**
* Check for property definition present. Just checks the attributes of
* the current element.
*
* @param ctx unmarshalling context information
*/
private static boolean isPropertyPresent(UnmarshallingContext ctx) {
return ctx.attributeText(URI_ATTRIBUTES, COMMON_FIELD, null) != null ||
ctx.attributeText(URI_ATTRIBUTES, COMMON_GETMETHOD, null) != null ||
ctx.attributeText(URI_ATTRIBUTES, COMMON_SETMETHOD, null) != null ||
ctx.attributeText(URI_ATTRIBUTES, COMMON_TESTMETHOD, null) != null;
}
/**
* Check if attributes define a direct object reference. Just checks the
* attributes of the current element.
*
* @param ctx unmarshalling context information
*/
private static boolean isDirectObject(UnmarshallingContext ctx) {
return ctx.attributeText(URI_ATTRIBUTES,
COMMON_MARSHALLER, null) != null ||
ctx.attributeText(URI_ATTRIBUTES,
COMMON_UNMARSHALLER, null) != null;
}
/**
* Check if attributes define a mapping reference.
*
* @param ctx unmarshalling context information
* @return true if attributes define a mapping reference,
* false if not
* @throws JiBXException if error in unmarshalling
*/
private static boolean isMappingRef(UnmarshallingContext ctx)
throws JiBXException {
return ctx.hasAttribute(URI_ATTRIBUTES, STRUCTURE_MAPAS);
}
/**
* Check for component object present. Just checks the attributes of the
* current element, so this is not definitive - there may still be child
* binding definitions even without attributes.
*
* @param ctx unmarshalling context information
* @throws JiBXException if error in unmarshalling
*/
private static boolean isObjectBinding(UnmarshallingContext ctx)
throws JiBXException {
return ctx.hasAnyAttribute(COMPONENT_OBJECT_NAMESPACES,
COMPONENT_OBJECT_NAMES);
}
/**
* Unmarshal name definition. This unmarshals directly from attributes of
* the current element.
*
* @param ctx unmarshalling context information
* @param attr flag for attribute name definition
* @throws JiBXException if error in unmarshalling
*/
private static NameDefinition unmarshalName(UnmarshallingContext ctx,
boolean attr) throws JiBXException {
String name = ctx.attributeText(URI_ATTRIBUTES, COMMON_NAME);
String ns = ctx.attributeText(URI_ATTRIBUTES, COMMON_NAMESPACE, null);
return new NameDefinition(name, ns, attr);
}
/**
* Unmarshal namespace definition.
*
* @param ctx unmarshalling context information
* @throws JiBXException if error in unmarshalling
*/
private static NamespaceDefinition unmarshalNamespace
(UnmarshallingContext ctx) throws JiBXException {
// set up the basic information
String uri = ctx.attributeText(URI_ATTRIBUTES, NAMESPACE_URI);
String prefix = ctx.attributeText(URI_ATTRIBUTES,
NAMESPACE_PREFIX, null);
if ("".equals(prefix)) {
prefix = null;
}
// check default usage attribute
int usage = ctx.attributeEnumeration(URI_ATTRIBUTES, NAMESPACE_DEFAULT,
NAMESPACEACCESS_NAMES, NAMESPACEACCESS_NUMS,
NamespaceDefinition.NODEFAULT_USAGE);
// finish parsing the element
ctx.parsePastEndTag(URI_ELEMENTS, NAMESPACE_ELEMENT);
return new NamespaceDefinition(uri, prefix, usage);
}
/**
* Add (or verify) serializer and deserializer methods to enum class with
* special value method. This allows enums to be used even when the values
* present in XML are not valid Java names.
*
* @param exists only verify existing methods flag
* @param type
* @param evmeth
* @throws JiBXException
*/
private static void buildEnumValueMethods(boolean exists, String type,
String evmeth) throws JiBXException {
// set up for adding serialize/deserialize methods to enum class
BoundClass bndclas = BoundClass.getInstance(type, null);
ClassFile ecf = bndclas.getClassFile();
String typesig = ecf.getSignature();
String evfull = type + '.' + evmeth;
String sersig = "(" + typesig + ")Ljava/lang/String;";
String dsersig = "(Ljava/lang/String;)" + typesig;
// check verify vs. add
if (exists) {
// just verify existing methods
if (ecf.getMethod(CUSTOM_ENUM_SERIALIZER_NAME,
new String[] { sersig }) == null) {
throw new JiBXException("Expected serializer method " +
CUSTOM_ENUM_SERIALIZER_NAME + " not found in enum class " +
type);
}
if (ecf.getMethod(CUSTOM_ENUM_DESERIALIZER_NAME,
new String[] { dsersig }) == null) {
throw new JiBXException("Expected deserializer method " +
CUSTOM_ENUM_DESERIALIZER_NAME +
" not found in enum class " + type);
}
} else {
// build the serializer method (just delegates to value method)
ClassFile cf = bndclas.getMungedFile();
ExceptionMethodBuilder smeth = new ExceptionMethodBuilder
(CUSTOM_ENUM_SERIALIZER_NAME, sersig, cf,
Constants.ACC_PUBLIC | Constants.ACC_STATIC);
smeth.appendLoadLocal(0);
BranchWrapper nonnull = smeth.appendIFNONNULL(smeth);
smeth.appendACONST_NULL();
smeth.appendReturn("java.lang.String");
smeth.targetNext(nonnull);
smeth.appendLoadLocal(0);
smeth.appendCallVirtual(evfull, "()Ljava/lang/String;");
smeth.appendReturn("java.lang.String");
bndclas.getUniqueNamed(smeth);
// create the deserializer method
ExceptionMethodBuilder dmeth = new ExceptionMethodBuilder
(CUSTOM_ENUM_DESERIALIZER_NAME, dsersig, cf,
Constants.ACC_PUBLIC | Constants.ACC_STATIC);
dmeth.addException(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
// start by handling the null string case
dmeth.appendLoadLocal(0);
nonnull = dmeth.appendIFNONNULL(dmeth);
dmeth.appendACONST_NULL();
dmeth.appendReturn(type);
dmeth.targetNext(nonnull);
// set up locals for array of values and decrementing index
dmeth.appendCallStatic(type + ".values", "()[" + typesig);
dmeth.appendDUP();
int arraylocal = dmeth.addLocal("values",
ClassItem.typeFromName(type + "[]"));
dmeth.appendARRAYLENGTH();
int arrayindex = dmeth.addLocal("index",
ClassItem.typeFromName("int"));
// start comparison loop with check for off bottom of array
BranchTarget start = dmeth.appendTargetNOP();
dmeth.appendIncrementLocal(-1, arrayindex);
dmeth.appendLoadLocal(arrayindex);
BranchWrapper loadnext = dmeth.appendIFGE(dmeth);
// throw an exception for value not found
dmeth.appendCreateNew("java.lang.StringBuffer");
dmeth.appendDUP();
dmeth.appendLoadConstant("No match found for value '");
dmeth.appendCallInit("java.lang.StringBuffer",
"(Ljava/lang/String;)V");
dmeth.appendLoadLocal(0);
dmeth.appendCallVirtual("java.lang.StringBuffer.append",
"(Ljava/lang/String;)Ljava/lang/StringBuffer;");
dmeth.appendLoadConstant("' in enum class " + type);
dmeth.appendCallVirtual("java.lang.StringBuffer.append",
"(Ljava/lang/String;)Ljava/lang/StringBuffer;");
dmeth.appendCallVirtual("java.lang.StringBuffer.toString",
"()Ljava/lang/String;");
dmeth.appendCreateNew(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
dmeth.appendDUP_X1();
dmeth.appendSWAP();
dmeth.appendCallInit(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS,
MethodBuilder.EXCEPTION_CONSTRUCTOR_SIGNATURE1);
dmeth.appendThrow();
// load and compare the value
dmeth.targetNext(loadnext);
dmeth.appendLoadLocal(0);
dmeth.appendLoadLocal(arraylocal);
dmeth.appendLoadLocal(arrayindex);
dmeth.appendALOAD(type);
dmeth.appendCallVirtual(evfull, "()Ljava/lang/String;");
dmeth.appendCallVirtual("java.lang.Object.equals",
"(Ljava/lang/Object;)Z");
BranchWrapper tonext = dmeth.appendIFEQ(dmeth);
tonext.setTarget(start, dmeth);
// return the matching instance
dmeth.appendLoadLocal(arraylocal);
dmeth.appendLoadLocal(arrayindex);
dmeth.appendALOAD(type);
dmeth.appendReturn(type);
// add completed method to class
bndclas.getUniqueNamed(dmeth);
}
}
/**
* Unmarshal string conversion. Unmarshals conversion information directly
* from the attributes of the current start tag.
*
* @param ctx unmarshalling context information
* @param exists only verify existing methods flag
* @param base conversion used as base for this conversion
* @param type fully qualified class name of type handled by conversion
* @throws JiBXException if error in unmarshalling
*/
private static StringConversion unmarshalStringConversion
(UnmarshallingContext ctx, boolean exists, StringConversion base,
String type) throws JiBXException {
String dflt = ctx.attributeText(URI_ATTRIBUTES, COMMON_DEFAULT, null);
String ser = ctx.attributeText(URI_ATTRIBUTES, COMMON_SERIALIZER, null);
String dser = ctx.attributeText(URI_ATTRIBUTES,
COMMON_DESERIALIZER, null);
String evmeth = ctx.attributeText(URI_ATTRIBUTES,
COMMON_ENUMVALUEMETHOD, null);
if (evmeth != null) {
ser = type + '.' + CUSTOM_ENUM_SERIALIZER_NAME;
dser = type + '.' + CUSTOM_ENUM_DESERIALIZER_NAME;
buildEnumValueMethods(exists, type, evmeth);
}
String wsconv = ctx.attributeText(URI_ATTRIBUTES, COMMON_WHITESPACE, null);
if (wsconv != null) {
if ("preserve".equals(wsconv)) {
wsconv = null;
} else {
wsconv = "org.jibx.runtime.WhitespaceConversions." + wsconv;
}
}
return base.derive(type, ser, wsconv, dser, dflt);
}
/**
* Check for optional property. Just checks for the attribute and makes sure
* it has a valid value if present, returning either the default or the
* defined value.
*
* @param ctx unmarshalling context information
* @return true if attribute present with value "true",
* false otherwise
* @throws JiBXException if error in unmarshalling
*/
private static boolean isOptionalProperty(UnmarshallingContext ctx)
throws JiBXException {
boolean opt = false;
String value = ctx.attributeText(URI_ATTRIBUTES, COMMON_USAGE,
USAGE_REQUIRED);
if (USAGE_OPTIONAL.equals(value)) {
opt = true;
} else if (!USAGE_REQUIRED.equals(value)) {
ctx.throwStartTagException("Illegal value for \"" + COMMON_USAGE+
"\" attribute");
}
return opt;
}
/**
* Unmarshal property definition. This unmarshals directly from attributes
* of the current element.
*
* @param ctx unmarshalling context information
* @param parent containing binding definition structure
* @param cobj context object information
* @param opt force optional value flag
* @throws JiBXException if error in unmarshalling
*/
private static PropertyDefinition unmarshalProperty
(UnmarshallingContext ctx, IContainer parent, IContextObj cobj,
boolean opt) throws JiBXException {
// read basic attribute values for property definition
String type = ctx.attributeText(URI_ATTRIBUTES, COMMON_TYPE, null);
if (!(parent instanceof NestedCollection) && isOptionalProperty(ctx)) {
opt = true;
}
// read and validate method and/or field attribute values
PropertyDefinition pdef = null;
try {
String fname = ctx.attributeText(URI_ATTRIBUTES,
COMMON_FIELD, null);
String test = ctx.attributeText(URI_ATTRIBUTES,
COMMON_TESTMETHOD, null);
String get = ctx.attributeText(URI_ATTRIBUTES,
COMMON_GETMETHOD, null);
String set = ctx.attributeText(URI_ATTRIBUTES,
COMMON_SETMETHOD, null);
String flag = ctx.attributeText(URI_ATTRIBUTES,
COMMON_FLAGMETHOD, null);
boolean isthis = fname == null && get == null && set == null &&
flag == null;
pdef = new PropertyDefinition
(parent, cobj, type, isthis, opt, fname, test, flag, get, set);
} catch (JiBXException ex) {
// rethrow error message with position information
ctx.throwStartTagException(ex.getMessage());
}
return pdef;
}
/**
* Unmarshal value definition. This handles the complete element supplying
* the value binding.
*
* @param ctx unmarshalling context information
* @param parent containing binding definition structure
* @param cobj context object information
* @param uord unordered collection member flag
* @param impl implicit value from collection flag
* @param itype base type for value
* @throws JiBXException if error in unmarshalling
*/
private static ValueChild unmarshalValue(UnmarshallingContext ctx,
IContainer parent, IContextObj cobj, boolean uord, boolean impl,
String itype) throws JiBXException {
// find the style for this value
int style = ctx.attributeEnumeration(URI_ATTRIBUTES, VALUE_STYLE,
VALUE_STYLE_NAMES, VALUE_STYLE_NUMS, parent.getStyleDefault());
// set up the basic structures
boolean isatt = style == ValueChild.ATTRIBUTE_STYLE;
NameDefinition name = null;
if (isatt || style == ValueChild.ELEMENT_STYLE) {
name = unmarshalName(ctx, isatt);
name.fixNamespace(parent.getDefinitionContext());
} else if (isNamePresent(ctx)) {
ctx.throwStartTagException
("Name not allowed for text or CDATA value");
}
String constant = ctx.attributeText(URI_ATTRIBUTES,
VALUE_CONSTANT, null);
// handle property information (unless auto ident or implicit value)
int ident = ctx.attributeEnumeration(URI_ATTRIBUTES, VALUE_IDENT,
IDENTTYPE_NAMES, IDENTTYPE_NUMS, ValueChild.DIRECT_IDENT);
PropertyDefinition prop = null;
if (ident == ValueChild.AUTO_IDENT) {
ctx.throwStartTagException
("Automatic id generation not yet supported");
} else if (impl) {
String type = ctx.attributeText(URI_ATTRIBUTES, COMMON_TYPE, itype);
prop = new PropertyDefinition(type, cobj,
!(parent instanceof NestedCollection) && isOptionalProperty(ctx));
} else {
prop = unmarshalProperty(ctx, parent, cobj,
ctx.hasAttribute(URI_ATTRIBUTES, COMMON_DEFAULT));
/* if (constant == null && prop.isThis()) {
ctx.throwStartTagException("No property for value");
} else if (prop.isOptional()) {
if (ident == ValueChild.DEF_IDENT) {
ctx.throwStartTagException("Object ID cannot be optional");
}
} else if (uord) {
ctx.throwStartTagException("All items in unordered " +
"structure must be optional");
} */
}
if (ident != ValueChild.DIRECT_IDENT && uord) {
ctx.throwStartTagException(VALUE_IDENT +
" not allowed in unordered structure");
}
// get serializer/deserializer attributes now to allow enum override
String ser = ctx.attributeText(URI_ATTRIBUTES, COMMON_SERIALIZER, null);
String wsconv = ctx.attributeText(URI_ATTRIBUTES, COMMON_WHITESPACE, null);
if (wsconv != null) {
if ("preserve".equals(wsconv)) {
wsconv = null;
} else {
wsconv = "org.jibx.runtime.WhitespaceConversions." + wsconv;
}
}
String dser = ctx.attributeText(URI_ATTRIBUTES,
COMMON_DESERIALIZER, null);
// check for enum with value method
String type = (prop == null || constant != null) ?
"java.lang.String" : prop.getTypeName();
String evmeth = ctx.attributeText(URI_ATTRIBUTES,
COMMON_ENUMVALUEMETHOD, null);
boolean basicenum = false;
ClassFile target = ClassCache.requireClassFile(type);
if (evmeth != null) {
// handle enum using generated serialize and deserialize methods
ser = type + '.' + CUSTOM_ENUM_SERIALIZER_NAME;
dser = type + '.' + CUSTOM_ENUM_DESERIALIZER_NAME;
buildEnumValueMethods(false, type, evmeth);
} else {
// check for a Java 5 enumeration
ClassFile sclas = target;
while ((sclas = sclas.getSuperFile()) != null) {
if (sclas.getName().equals("java.lang.Enum")) {
basicenum = true;
break;
}
}
}
// find the basic converter to use
StringConversion convert = null;
String format = ctx.attributeText(URI_ATTRIBUTES, VALUE_FORMAT, null);
DefinitionContext defc = parent.getDefinitionContext();
if (format == null) {
// no format name, get specific convertor for type or best match
convert = defc.getSpecificConversion(type);
if (convert == null) {
// find best match converter for type
convert = defc.getConversion(target);
// generate specific converter based on general form
if (basicenum) {
String basedeser = type + '.' + "valueOf";
convert = convert.derive(type, null, null, basedeser, null);
} else if (convert.getTypeName().equals("java.lang.Object")) {
convert = new ObjectStringConversion(type,
(ObjectStringConversion)convert);
}
}
} else {
// format name supplied, look it up and check compatibility
QName qname = QName.deserialize(format, ctx);
convert = defc.getNamedConversion(qname);
if (convert == null) {
ctx.throwStartTagException
("Unknown format \"" + format + "\"");
}
String ctype = convert.getTypeName();
if (!ClassItem.isAssignable(type, ctype) &&
!ClassItem.isAssignable(ctype, type)) {
ctx.throwStartTagException
("Converter type not compatible with value type");
}
}
// check for any special conversion handling
String dflt = ctx.attributeText(URI_ATTRIBUTES, COMMON_DEFAULT, null);
if (dflt != null || ser != null || wsconv != null || dser != null) {
convert = convert.derive(type, ser, wsconv, dser, dflt);
}
// create the instance to be returned
boolean nillable = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_NILLABLE, false);
if (nillable) {
parent.getBindingRoot().setSchemaInstanceUsed();
}
ValueChild value = new ValueChild(parent, cobj, name, prop, convert,
style, ident, constant, nillable);
// handle identifier property flag
if (ident == ValueChild.DEF_IDENT || ident == ValueChild.AUTO_IDENT) {
if (!cobj.setIdChild(value)) {
ctx.throwStartTagException
("Duplicate ID definition for containing mapping");
} else if (!"java.lang.String".equals(type)) {
ctx.throwStartTagException
("ID property must be a String");
}
}
// finish with skipping past end tag
ctx.parsePastEndTag(URI_ELEMENTS, VALUE_ELEMENT);
return value;
}
/**
* Unmarshal direct object component. Just constructs the component to
* be returned along with the supporting objects, and verifies that no
* disallowed properties are present.
*
* @param ctx unmarshalling context information
* @param type fully qualified class name of object type handled
* @param parent containing binding definition structure
* @param defc definition context to be used (if separate from parent,
* otherwise null)
* @param mapname marshaller/unmarshaller name
* @param name element name information (null if no element
* name)
* @return constructed direct object component
* @throws JiBXException if error in unmarshalling
*/
private static DirectObject unmarshalDirectObj(UnmarshallingContext ctx,
String type, IContainer parent, DefinitionContext defc, String mapname,
NameDefinition name) throws JiBXException {
// define and validate marshaller
ClassFile mcf = null;
if (parent.getBindingRoot().isOutput()) {
String clas = ctx.attributeText(URI_ATTRIBUTES, COMMON_MARSHALLER);
mcf = ClassCache.requireClassFile(clas);
if (!mcf.isImplements(MARSHALLER_INTERFACETYPE)) {
ctx.throwStartTagException("Marshaller class " + clas +
" does not implement required interface " +
MARSHALLER_INTERFACE);
}
}
// define and validate unmarshaller
ClassFile ucf = null;
if (parent.getBindingRoot().isInput()) {
String clas = ctx.attributeText(URI_ATTRIBUTES,
COMMON_UNMARSHALLER);
ucf = ClassCache.requireClassFile(clas);
if (!ucf.isImplements(UNMARSHALLER_INTERFACETYPE)) {
ctx.throwStartTagException("Unmarshaller class " + clas +
" does not implement required interface " +
UNMARSHALLER_INTERFACE);
}
}
// make sure none of the prohibited attributes are present
if (isObjectBinding(ctx)) {
ctx.throwStartTagException("Other object attributes not " +
"allowed when using marshaller or unmarshaller");
} else if (isMappingRef(ctx)) {
ctx.throwStartTagException("Mapping not allowed when " +
"using marshaller or unmarshaller");
} else if (ctx.hasAttribute(URI_ATTRIBUTES, COMMON_USING)) {
ctx.throwStartTagException(COMMON_USING +
" attribute not allowed when using marshaller or unmarshaller");
}
// return constructed instance
return new DirectObject(parent, defc, ClassCache.requireClassFile(type),
false, mcf, ucf, mapname, name, null);
}
/**
* Unmarshal mapping reference component. Just constructs the component to
* be returned along with the supporting objects, and verifies that no
* disallowed properties are present.
*
* @param ctx unmarshalling context information
* @param parent containing binding definition structure
* @param objc current object context
* @param prop property definition
* @param name reference name definition (only allowed with abstract
* mappings)
* @return constructed mapping reference component
* @throws JiBXException if error in unmarshalling
*/
private static IComponent unmarshalMappingRef(UnmarshallingContext ctx,
IContainer parent, IContextObj objc, PropertyDefinition prop,
NameDefinition name) throws JiBXException {
// make sure no forbidden attributes are present
if (isObjectBinding(ctx)) {
ctx.throwStartTagException("Other object attributes not " +
"allowed when using mapping reference");
} else if (ctx.hasAttribute(URI_ATTRIBUTES, COMMON_USING)) {
ctx.throwStartTagException(COMMON_USING +
" attribute not allowed when using mapping reference");
}
// build the actual component to be returned
String type = (prop == null) ? null : prop.getTypeName();
String text = ctx.attributeText(URI_ATTRIBUTES, STRUCTURE_MAPAS, type);
QName qname = QName.deserialize(text, ctx);
boolean nillable = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_NILLABLE, false);
if (nillable) {
parent.getBindingRoot().setSchemaInstanceUsed();
}
return new MappingReference(parent, prop, type, text, qname.toString(),
objc, name, false, nillable);
}
/**
* Unmarshal structure reference component. Just constructs the component to
* be returned along with the supporting objects, and verifies that no
* disallowed properties are present.
*
* @param ctx unmarshalling context information
* @param contain containing binding component
* @param name element name information (null if no element
* name)
* @param prop property definition (null if no separate
* property)
* @param cobj context object
* @return constructed structure reference component
* @throws JiBXException if error in unmarshalling
*/
private static IComponent unmarshalStructureRef(UnmarshallingContext ctx,
IContainer contain, NameDefinition name, PropertyDefinition prop,
IContextObj cobj) throws JiBXException {
// make sure no forbidden attributes are present
if (isObjectBinding(ctx)) {
ctx.throwStartTagException("Other object attributes not " +
"allowed when using structure reference");
}
// build the actual component to be returned
String ident = ctx.attributeText(URI_ATTRIBUTES, COMMON_USING);
IComponent comp = new StructureReference(contain, ident, prop,
name != null, cobj);
if (name != null) {
boolean nillable = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_NILLABLE, false);
if (nillable) {
contain.getBindingRoot().setSchemaInstanceUsed();
}
comp = new ElementWrapper(contain.getDefinitionContext(),
name, comp, nillable);
if (prop != null && prop.isOptional()) {
((ElementWrapper)comp).setOptionalNormal(true);
((ElementWrapper)comp).setStructureObject(true);
comp = new OptionalStructureWrapper(comp, prop, true);
prop.setOptional(false);
}
}
return comp;
}
/**
* Unmarshal child bindings for a nested structure definition.
*
* @param ctx unmarshalling context information
* @param nest nested structure definition
* @param objc context object definition
* @param impl property value implicit flag
* @param itype item type for child components
* @throws JiBXException if error in unmarshalling
*/
private static void unmarshalStructureChildren(UnmarshallingContext ctx,
NestedBase nest, IContextObj objc, boolean impl, String itype)
throws JiBXException {
boolean uord = !nest.isContentOrdered();
while (true) {
// unmarshal next child binding definition
IComponent comp;
if (ctx.isAt(URI_ELEMENTS, VALUE_ELEMENT)) {
ValueChild child =
unmarshalValue(ctx, nest, objc, uord, impl, itype);
comp = child;
} else if (ctx.isAt(URI_ELEMENTS, STRUCTURE_ELEMENT)) {
comp = unmarshalStructure(ctx, nest, objc, false, uord, impl);
} else if (ctx.isAt(URI_ELEMENTS, COLLECTION_ELEMENT)) {
comp = unmarshalStructure(ctx, nest, objc, true, uord, impl);
} else {
break;
}
// add component to structure
nest.addComponent(comp);
}
}
/**
* Unmarshal object binding component. Just constructs the component to
* be returned along with the supporting objects. This handles both the
* unmarshalling of attributes, and of nested binding components.
*
* @param ctx unmarshalling context information
* @param parent containing binding definition structure
* @param objc current object context
* @param type fully qualified name of object class
* @return constructed structure reference component
* @throws JiBXException if error in unmarshalling
*/
private static ObjectBinding unmarshalObjectBinding
(UnmarshallingContext ctx, IContextObj objc, IContainer parent,
String type) throws JiBXException {
// set method names from attributes of start tag
String fact = ctx.attributeText(URI_ATTRIBUTES, COMMON_FACTORY, null);
String pres = ctx.attributeText(URI_ATTRIBUTES, COMMON_PRESET, null);
String posts = ctx.attributeText(URI_ATTRIBUTES, COMMON_POSTSET, null);
String preg = ctx.attributeText(URI_ATTRIBUTES, COMMON_PREGET, null);
String ctype = ctx.attributeText(URI_ATTRIBUTES,
COMMON_CREATETYPE, null);
ObjectBinding bind = null;
try {
bind = new ObjectBinding(parent, objc, type, fact, pres,
posts, preg, ctype);
} catch (JiBXException ex) {
ctx.throwStartTagException(ex.getMessage(), ex);
}
return bind;
}
/**
* Unmarshal namespace definitions. Any namespace definitions present are
* unmarshalled and added to the supplied definition context.
*
* @param ctx unmarshalling context information
* @param defc definition context for defined namespaces
* @throws JiBXException if error in unmarshalling
*/
private static void unmarshalNamespaces(UnmarshallingContext ctx,
DefinitionContext defc) throws JiBXException {
while (ctx.isAt(URI_ELEMENTS, NAMESPACE_ELEMENT)) {
defc.addNamespace(unmarshalNamespace(ctx));
}
}
/**
* Unmarshal format definitions. Any format definitions present are
* unmarshalled and added to the supplied definition context.
*
* @param ctx unmarshalling context information
* @param exists only verify existing methods flag
* @param defc definition context for defined formats
* @throws JiBXException if error in unmarshalling
*/
private static void unmarshalFormats(UnmarshallingContext ctx,
boolean exists, DefinitionContext defc) throws JiBXException {
// process all format definitions at level
while (ctx.isAt(URI_ELEMENTS, FORMAT_ELEMENT)) {
// find the current default format information for type
String type = ctx.attributeText(URI_ATTRIBUTES, FORMAT_TYPE);
String sig = org.apache.bcel.classfile.Utility.getSignature(type);
StringConversion base = null;
if (sig.length() == 1) {
// must be a primitive, check type directly
base = defc.getSpecificConversion(type);
if (base == null) {
ctx.throwStartTagException("Unsupported \"" +
FORMAT_TYPE + "\" value");
}
} else {
// must be an object type, find best match
ClassFile cf = ClassCache.requireClassFile(type);
base = defc.getConversion(cf);
}
// unmarshal with defaults provided by existing format
StringConversion format =
unmarshalStringConversion(ctx, exists, base, type);
// handle based on presence or absence of name attribute
String text = ctx.attributeText(URI_ATTRIBUTES, FORMAT_NAME, null);
if (text == null) {
defc.setConversion(format);
} else {
QName qname = QName.deserialize(text, ctx);
defc.setNamedConversion(qname, format);
}
// scan past end of definition
ctx.parsePastEndTag(URI_ELEMENTS, FORMAT_ELEMENT);
}
}
/**
* Unmarshal mapping definitions. Any mapping definitions present are
* unmarshalled and added to the supplied definition context.
*
* @param ctx unmarshalling context information
* @param parent containing binding definition structure
* @param nss extra namespaces to be included in this mapping definition
* (may be null)
* @param uord container is unordered structure flag
* @throws JiBXException if error in unmarshalling
*/
private static void unmarshalMappings(UnmarshallingContext ctx,
IContainer parent, ArrayList nss, boolean uord) throws JiBXException {
while (ctx.isAt(URI_ELEMENTS, MAPPING_ELEMENT)) {
unmarshalMapping(ctx, parent, nss, uord);
}
}
/**
* Unmarshal subclass instance for structure definition. This handles all
* combinations of attributes on the start tag, generating the appropriate
* structure of nested components and other classes to represent the binding
* information within the current element. This must be called with the
* parse positioned at the start tag of the element to be unmarshalled.
*
* TODO: At least split this up, or organize a better way to build binding
*
* @param ctx unmarshalling context information
* @param contain containing binding definition structure
* @param cobj context object information
* @param coll collection structure flag
* @param uord container is unordered structure flag
* @param implic property value implicit flag
* @return root of component tree constructed from binding
* @throws JiBXException if error in unmarshalling
*/
public static IComponent unmarshalStructure(UnmarshallingContext ctx,
IContainer contain, IContextObj cobj, boolean coll, boolean uord,
boolean implic) throws JiBXException {
// get name definition if supplied (check later to see if valid)
NameDefinition name = null;
if (isNamePresent(ctx)) {
name = unmarshalName(ctx, false);
}
// check for optional flag on structure
boolean opt = isOptionalProperty(ctx);
boolean incoll = false;
if (contain instanceof NestedCollection) {
incoll = true;
opt = false;
}
// check for property definition supplied
IComponent comp;
boolean hasprop = isPropertyPresent(ctx);
boolean thisref = false;
if (!hasprop) {
thisref = incoll || ctx.hasAttribute(URI_ATTRIBUTES, COMMON_TYPE);
}
boolean mapping = isMappingRef(ctx);
if (hasprop || coll || implic || thisref) {
// set up the property definition to be used
PropertyDefinition prop = null;
boolean hasobj = hasprop;
if (implic) {
// make sure no override of implicit property from collection
if (hasprop) {
ctx.throwStartTagException("Property definition not " +
"allowed for collection items");
} else {
String type = ctx.attributeText(URI_ATTRIBUTES,
COMMON_TYPE, null);
if (type == null) {
if (!mapping) {
if (incoll) {
type = ((NestedCollection)contain).getItemType();
hasobj = true;
} else {
type = "java.lang.Object";
}
}
} else {
hasobj = true;
}
prop = new PropertyDefinition(type, cobj, opt);
}
} else if (hasprop || thisref) {
prop = unmarshalProperty(ctx, contain, cobj, opt);
} else {
prop = new PropertyDefinition(cobj, opt);
}
// check if using direct object marshalling and unmarshalling
if (isDirectObject(ctx)) {
// validate and configure direct marshalling and unmarshalling
comp = new DirectProperty(prop, unmarshalDirectObj(ctx,
prop.getTypeName(), contain, null, null, name));
} else if (mapping) {
// validate and configure reference to mapping in context
comp = unmarshalMappingRef(ctx, contain, cobj, prop, name);
} else {
// check for object binding needed
IContextObj icobj = cobj;
ObjectBinding bind = null;
boolean typed = false;
if (implic) {
typed = !prop.getTypeName().equals("java.lang.Object");
} else {
typed = !prop.getTypeName().equals
(cobj.getBoundClass().getClassName());
}
if (!prop.isFlagOnly() &&
((hasobj && !prop.isThis()) || (!hasobj && typed))) {
bind = unmarshalObjectBinding(ctx, cobj, contain,
prop.getTypeName());
icobj = bind;
}
// validate and configure reference to structure in context
if (ctx.hasAttribute(URI_ATTRIBUTES, COMMON_USING)) {
comp = unmarshalStructureRef(ctx, contain, name,
prop, icobj);
} else {
// validate and configure actual binding definition
DefinitionContext defc = contain.getDefinitionContext();
IComponent top = bind;
// check for optional label definition
String label = ctx.attributeText(URI_ATTRIBUTES,
COMMON_LABEL, null);
// set load and store handlers for collection
NestedCollection.CollectionLoad load = null;
NestedCollection.CollectionStore store = null;
String itype = null;
if (coll) {
// get any method names and type supplied by user
String stname = ctx.attributeText(URI_ATTRIBUTES,
COLLECTION_STOREMETHOD, null);
String aname = ctx.attributeText(URI_ATTRIBUTES,
COLLECTION_ADDMETHOD, null);
String lname = ctx.attributeText(URI_ATTRIBUTES,
COLLECTION_LOADMETHOD, null);
String szname = ctx.attributeText(URI_ATTRIBUTES,
COLLECTION_SIZEMETHOD, null);
String iname = ctx.attributeText(URI_ATTRIBUTES,
COLLECTION_ITERMETHOD, null);
itype = ctx.attributeText(URI_ATTRIBUTES,
COLLECTION_ITEMTYPE, "java.lang.Object");
// verify combinations of attributes supplied
if ((lname == null || szname == null) &&
!(lname == null && szname == null)) {
ctx.throwStartTagException(COLLECTION_LOADMETHOD +
" and " + COLLECTION_SIZEMETHOD +
" attributes must be used together");
}
if (iname != null && lname != null) {
ctx.throwStartTagException(COLLECTION_ITERMETHOD +
" and " + COLLECTION_LOADMETHOD +
" attributes cannot be used together");
}
if (aname != null && stname != null) {
ctx.throwStartTagException(COLLECTION_ADDMETHOD +
" and " + COLLECTION_STOREMETHOD +
" attributes cannot be used together");
}
// set defaults based on collection type
ClassFile cf = ClassCache.requireClassFile
(prop.getTypeName());
if (cf.isSuperclass("java.util.Vector")||
cf.isSuperclass("java.util.ArrayList")) {
if (stname == null && aname == null) {
aname = "add";
}
if (iname == null && lname == null) {
lname = "get";
szname = "size";
}
} else if (cf.isImplements("Ljava/util/Collection;")) {
if (stname == null && aname == null) {
aname = "add";
}
if (iname == null && lname == null) {
iname = "iterator";
}
} else if (cf.isArray()) {
String ptype = prop.getTypeName();
itype = ptype.substring(0, ptype.length()-2);
}
// check binding direction(s)
BindingDefinition bdef = contain.getBindingRoot();
boolean isdoub =
"long".equals(itype) || "double".equals(itype);
if (bdef.isInput()) {
// define strategy for adding items to collection
if (aname != null) {
ClassItem meth = cf.getBestMethod(aname,
null, new String[] { itype });
if (meth == null) {
ctx.throwStartTagException
("Add method " + aname +
" not found in collection type " +
cf.getName());
}
boolean hasval =
!"void".equals(meth.getTypeName());
store = new NestedCollection.AddStore(meth,
isdoub, hasval);
} else if (stname != null) {
ClassItem meth = cf.getBestMethod(stname,
null, new String[] { "int", itype });
if (meth == null) {
ctx.throwStartTagException
("Indexed store method " + stname +
" not found in collection type " +
cf.getName());
}
boolean hasval =
!"void".equals(meth.getTypeName());
store = new NestedCollection.IndexedStore(meth,
isdoub, hasval);
} else if (cf.isArray()) {
store = new NestedCollection.ArrayStore(itype,
isdoub);
} else {
ctx.throwStartTagException
("Unknown collection " +
"type with no add or store method defined");
}
}
if (bdef.isOutput()) {
// define strategy for loading items from collection
if (lname != null) {
ClassItem smeth = cf.getMethod(szname, "()I");
if (smeth == null) {
ctx.throwStartTagException
("Size method " + szname +
" not found in collection type " +
cf.getName());
}
ClassItem lmeth = cf.getBestMethod(lname,
itype, new String[] { "int" });
if (lmeth == null) {
ctx.throwStartTagException
("Load method " + lname +
" not found in collection type " +
cf.getName());
}
load = new NestedCollection.
IndexedLoad(smeth, isdoub, lmeth);
} else if (iname != null) {
String mname = "hasNext";
String nname = "next";
ClassItem meth = cf.getMethod(iname,
"()Ljava/util/Iterator;");
if (meth == null) {
mname = "hasMoreElements";
nname = "nextElement";
meth = cf.getMethod(iname,
"()Ljava/util/Enumeration;");
if (meth == null) {
ctx.throwStartTagException
("Iterator method " + iname +
" not found in collection type " +
cf.getName());
}
}
load = new NestedCollection.
IteratorLoad(meth, isdoub,
"java.util.Iterator." + mname,
"java.util.Iterator." + nname);
} else if (cf.isArray()) {
load = new NestedCollection.ArrayLoad(itype,
isdoub);
} else {
ctx.throwStartTagException
("Unknown collection " +
"type with no load method defined");
}
}
}
// unmarshal basics of nested structure
NestedBase nest;
boolean ordered = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_ORDERED, true);
boolean flex = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_FLEXIBLE, false);
boolean nillable = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_NILLABLE, false);
if (nillable) {
contain.getBindingRoot().setSchemaInstanceUsed();
}
if (coll) {
// create collection definition
nest = new NestedCollection(contain, icobj,
ordered, opt, flex, itype, load, store);
nest.unmarshal(ctx);
ctx.parsePastStartTag(URI_ELEMENTS,
COLLECTION_ELEMENT);
} else {
// create structure definition
boolean choice = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_CHOICE, false);
boolean dupl = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_DUPLICATES, false);
nest = new NestedStructure(contain, icobj,
ordered, choice, flex, false, hasobj, dupl);
nest.unmarshal(ctx);
ctx.parsePastStartTag(URI_ELEMENTS,
STRUCTURE_ELEMENT);
}
// unmarshal child bindings with optional label
String ctype = (itype == null) ? "java.lang.Object" : itype;
unmarshalFormats(ctx, false, nest.getDefinitionContext());
unmarshalMappings(ctx, contain, null, uord);
unmarshalStructureChildren(ctx, nest, icobj,
coll | (implic && !hasobj), ctype);
if (top == null) {
top = nest;
}
// special check for structure wrapping value
boolean impstruct = false;
boolean childs = nest.hasContent();
if (implic && !coll && childs) {
ArrayList contents = nest.getContents();
impstruct = true;
for (int i = 0; i < contents.size(); i++) {
if (!(contents.get(i) instanceof ValueChild)) {
impstruct = false;
break;
} else {
ValueChild vchild = (ValueChild)contents.get(i);
if (!vchild.isImplicit()) {
impstruct = false;
break;
}
}
}
}
if (impstruct) {
comp = nest;
nest.setObjectContext(cobj);
if (name != null) {
comp = new ElementWrapper(defc, name, comp, nillable);
if (bind != null && implic) {
if (!hasprop) {
((ElementWrapper)comp).setDirect(true);
ArrayList contents = nest.getContents();
impstruct = true;
for (int i = 0; i < contents.size(); i++) {
if (contents.get(i) instanceof ValueChild) {
ValueChild vchild = (ValueChild)contents.get(i);
vchild.switchProperty();
}
}
}
prop.setOptional(false);
}
}
} else {
// check for children defined
boolean addref = false;
if (!childs) {
if (coll) {
// add mapping as only child
if (ctype.equals("java.lang.Object")) {
nest.addComponent
(new DirectGeneric(nest, null));
} else {
nest.addComponent(new MappingReference(contain,
new PropertyDefinition(ctype, cobj, false),
ctype, null, null, icobj, null, true, false));
}
childs = true;
} else if (name != null && !prop.isFlagOnly()) {
// must be abstract mappping reference, create child
addref = true;
}
}
// handle nested children
comp = top;
if (childs || addref || prop.isFlagOnly()) {
// define component property wrapping object binding
boolean optprop = hasprop && prop.isOptional();
if (bind != null) {
boolean skip = name != null && optprop;
comp = new ComponentProperty(prop, comp, skip);
bind.setWrappedComponent(nest);
// create reference to mapping as special case
// this allows structure with name but no
// children to use abstract mapping
if (addref) {
PropertyDefinition thisprop =
new PropertyDefinition(bind, false);
nest.addComponent(new MappingReference
(nest, thisprop, comp.getType(), null,
null, icobj, null, false, false));
}
} else if (prop.isFlagOnly()) {
boolean skip = name != null && optprop;
comp = new ComponentProperty(prop, comp, skip);
}
if (name == null) {
if (optprop && prop.isTestOnly()) {
comp = new OptionalStructureWrapper(comp,
prop, bind != null);
prop.setOptional(false);
}
} else {
comp = new ElementWrapper(defc, name, comp,
nillable);
if (bind != null && implic) {
if (!hasprop) {
((ElementWrapper)comp).setDirect(true);
}
prop.setOptional(false);
}
if (optprop) {
((ElementWrapper)comp).setOptionalNormal(true);
boolean isobj = bind != null;
((ElementWrapper)comp).
setStructureObject(isobj);
((ElementWrapper)comp).setDirect(isobj);
comp = new OptionalStructureWrapper(comp, prop,
isobj);
prop.setOptional(false);
} else if (opt && !implic) {
((ElementWrapper)comp).setOptionalNormal(true);
comp = new OptionalStructureWrapper(comp, prop,
false);
prop.setOptional(false);
}
}
} else {
// treat as mapping, with either type or generic
String type = prop.getTypeName();
if (prop.equals("java.lang.Object")) {
comp = new ComponentProperty(prop, new
DirectGeneric(contain, null), false);
} else {
comp = new MappingReference(contain, prop, type,
null, null, icobj, name, false, false);
}
}
}
// set object binding as definition for label
if (label != null) {
defc.addNamedStructure(label, top);
}
}
}
} else {
// structure with no separate object, verify no forbidden attributes
if (isObjectBinding(ctx)) {
ctx.throwStartTagException("Object attributes not " +
"allowed without property definition");
} else if (isDirectObject(ctx)) {
ctx.throwStartTagException("Marshaller and unmarshaller not " +
"allowed without property definition");
}
// check for reference to structure defined elsewhere
if (mapping) {
// handle "this" reference as anonymous property
PropertyDefinition prop = new PropertyDefinition(cobj, opt);
// handle reference to defined mapping
comp = unmarshalMappingRef(ctx, contain, cobj, prop, name);
implic = true;
} else if (ctx.hasAttribute(URI_ATTRIBUTES, COMMON_USING)) {
// make sure forbidden attribute not used
if (ctx.hasAttribute(URI_ATTRIBUTES, COMMON_ORDERED)) {
ctx.throwStartTagException(COMMON_ORDERED + " attribute " +
" not allowed with " + COMMON_USING + " attribute");
}
// validate and configure reference to structure in context
comp = unmarshalStructureRef(ctx, contain, name, null, cobj);
} else {
// unmarshal children as nested structure
boolean ordered = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_ORDERED, true);
boolean choice = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_CHOICE, false);
boolean flex = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_FLEXIBLE, false);
boolean dupl = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_DUPLICATES, false);
NestedStructure nest = new NestedStructure(contain, cobj,
ordered, choice, flex, false, hasprop, dupl);
nest.unmarshal(ctx);
// unmarshal child bindings with optional label
String label = ctx.attributeText(URI_ATTRIBUTES,
COMMON_LABEL, null);
ctx.parsePastStartTag(URI_ELEMENTS, STRUCTURE_ELEMENT);
unmarshalFormats(ctx, false, nest.getDefinitionContext());
unmarshalMappings(ctx, contain, null, uord);
unmarshalStructureChildren(ctx, nest, cobj, false,
"java.lang.Object");
// check for children defined
DefinitionContext defc = contain.getDefinitionContext();
if (nest.hasContent()) {
// build structure to access children or with elment wrapper
if (name == null) {
comp = nest;
} else {
comp = new ElementWrapper(defc, name, nest, false);
if (opt) {
((ElementWrapper)comp).setOptionalNormal(true);
((ElementWrapper)comp).setStructureObject(true);
}
}
if (label != null) {
defc.addNamedStructure(label, nest);
}
} else {
// make sure there's a name defined
if (name == null) {
ctx.throwException
("Property, name, or child component required");
}
// treat as throwaway portion of document
comp = new ElementWrapper(defc, name, null, false);
if (opt) {
((ElementWrapper)comp).setOptionalIgnored(true);
}
}
}
}
// finish by parsing past end tag
ctx.parsePastEndTag(URI_ELEMENTS,
coll ? COLLECTION_ELEMENT : STRUCTURE_ELEMENT);
return comp;
}
/**
* Unmarshal mapping definition. This handles all combinations of attributes
* on the start tag, generating the appropriate structure of nested
* components and other classes to represent the binding information within
* the current element. This must be called with the parse positioned at the
* start tag of the element to be unmarshalled.
*
* @param ctx unmarshalling context information
* @param parent containing binding definition structure
* @param nss extra namespaces to be included in this mapping definition
* (may be null)
* @param uord container is unordered structure flag
* @return mapping definition constructed from binding
* @throws JiBXException if error in unmarshalling
*/
public static IMapping unmarshalMapping(UnmarshallingContext ctx,
IContainer parent, ArrayList nss, boolean uord) throws JiBXException {
// first check for an abstract mapping
boolean abs = ctx.attributeBoolean(URI_ATTRIBUTES,
MAPPING_ABSTRACT, false);
String type = ctx.attributeText(URI_ATTRIBUTES, MAPPING_CLASS);
// get name definition if supplied
NameDefinition name = null;
if (isNamePresent(ctx)) {
name = unmarshalName(ctx, false);
}
// get type name information
String text = ctx.attributeText(URI_ATTRIBUTES, MAPPING_TYPENAME, null);
String tname = null;
if (text != null) {
tname = QName.deserialize(text, ctx).toString();
}
// check if using direct object marshalling and unmarshalling
IMapping mapping;
if (isDirectObject(ctx)) {
// check for definition context needed
DefinitionContext defc = null;
if (nss != null && nss.size() > 0) {
// add all outer namespaces to context
defc = new DefinitionContext(parent);
if (nss != null && nss.size() > 0) {
for (int j = 0; j < nss.size(); j++) {
defc.addNamespace((NamespaceDefinition)nss.get(j));
}
}
}
// validate and configure direct marshalling and unmarshalling
parent.getBindingRoot().addMappingName(type);
mapping = new MappingDirect(parent, type, tname,
unmarshalDirectObj(ctx, type, parent, defc, type, name), abs);
} else {
// not direct mapping, check for missing required name
if (!abs && name == null) {
ctx.throwStartTagException("Non-abstract mapping must define " +
"an element name");
}
// check for optional definitions
String label = ctx.attributeText(URI_ATTRIBUTES,
COMMON_LABEL, null);
// create definition context for namespaces and formats
String base = ctx.attributeText(URI_ATTRIBUTES,
MAPPING_EXTENDS, null);
ObjectBinding bind = unmarshalObjectBinding(ctx, null,
parent, type);
boolean ordered = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_ORDERED, true);
boolean choice = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_CHOICE, false);
boolean flex = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_FLEXIBLE, false);
boolean nillable = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_NILLABLE, false);
if (nillable) {
parent.getBindingRoot().setSchemaInstanceUsed();
}
boolean dupl = ctx.attributeBoolean(URI_ATTRIBUTES,
COMMON_DUPLICATES, false);
NestedStructure nest = new NestedStructure(parent, bind,
ordered, choice, flex, true, true, dupl);
nest.unmarshal(ctx);
// add all outer namespaces to context
DefinitionContext defc = nest.getDefinitionContext();
if (nss != null && nss.size() > 0) {
for (int j = 0; j < nss.size(); j++) {
defc.addNamespace((NamespaceDefinition)nss.get(j));
}
}
// unmarshal all contained binding information
ctx.parsePastStartTag(URI_ELEMENTS, MAPPING_ELEMENT);
unmarshalNamespaces(ctx, nest.getDefinitionContext());
unmarshalFormats(ctx, false, nest.getDefinitionContext());
unmarshalMappings(ctx, nest, null, uord);
unmarshalStructureChildren(ctx, nest, bind, false,
"java.lang.Object");
// validate and configure actual binding definition
bind.setWrappedComponent(nest);
mapping = new MappingDefinition(parent, nest.getDefinitionContext(),
type, name, tname, abs, base, bind, nillable);
// set label if defined
if (label != null) {
defc.addNamedStructure(label, bind);
}
}
// finish by adding mapping and parsing past end tag
parent.getDefinitionContext().addMapping(mapping);
ctx.parsePastEndTag(URI_ELEMENTS, MAPPING_ELEMENT);
return mapping;
}
/**
* Force the class containing a method to be preserved from modification.
*
* @param name
*/
private static void preserveMethodClass(String name) {
if (name != null) {
int split = name.lastIndexOf('.');
ClassCache.addPreserveClass(name.substring(0, split));
}
}
/**
* Unmarshal precompiled mapping definitions. Any mapping definitions
* present are unmarshalled and added to the supplied definition context.
*
* @param ctx unmarshalling context information
* @param factory binding factory for mapping information
* @param parent containing binding definition structure
* @param nsxlate namespace index translation table (null if
* none)
* @throws JiBXException if error in unmarshalling
*/
private static void unmarshalPrecompiledMappings(UnmarshallingContext ctx,
IBindingFactory factory, IContainer parent, int[] nsxlate) throws JiBXException {
// flag classes with binding code as unmodifiable
String[] classes = factory.getBindingClasses();
for (int i = 0; i < classes.length; i++) {
ClassCache.addPreserveClass(classes[i]);
}
// build mapping from class name to index
classes = factory.getMappedClasses();
String[] names = factory.getElementNames();
StringIntHashMap namemap = new StringIntHashMap(names.length);
for (int i = 0; i < names.length; i++) {
String clasname = classes[i];
namemap.add(clasname, i);
}
// build mapping from abstract type name to index, and preserve classes
String[][] abstracts = factory.getAbstractMappings();
StringIntHashMap typemap = new StringIntHashMap(abstracts[0].length);
for (int i = 0; i < abstracts[0].length; i++) {
String name = abstracts[IBindingFactory.ABMAP_MAPPINGNAME_INDEX][i];
typemap.add(name, i);
preserveMethodClass(abstracts[IBindingFactory.ABMAP_ATTRMARMETH_INDEX][i]);
preserveMethodClass(abstracts[IBindingFactory.ABMAP_ATTRPRESMETH_INDEX][i]);
preserveMethodClass(abstracts[IBindingFactory.ABMAP_ATTRUMARMETH_INDEX][i]);
preserveMethodClass(abstracts[IBindingFactory.ABMAP_COMPLETEMETH_INDEX][i]);
preserveMethodClass(abstracts[IBindingFactory.ABMAP_CONTMARMETH_INDEX][i]);
preserveMethodClass(abstracts[IBindingFactory.ABMAP_CONTPRESMETH_INDEX][i]);
preserveMethodClass(abstracts[IBindingFactory.ABMAP_CONTUMARMETH_INDEX][i]);
preserveMethodClass(abstracts[IBindingFactory.ABMAP_CREATEMETH_INDEX][i]);
preserveMethodClass(abstracts[IBindingFactory.ABMAP_PREPAREMETH_INDEX][i]);
}
// process all the mapping definitions in binding
String[] namespaces = factory.getElementNamespaces();
String[] mars = factory.getMarshallerClasses();
String[] umars = factory.getUnmarshallerClasses();
while (ctx.isAt(URI_ELEMENTS, MAPPING_ELEMENT)) {
// first check for an abstract mapping
boolean abs = ctx.attributeBoolean(URI_ATTRIBUTES,
MAPPING_ABSTRACT, false);
String type = ctx.attributeText(URI_ATTRIBUTES, MAPPING_CLASS);
// get name definition if supplied
NameDefinition ndef = null;
if (isNamePresent(ctx)) {
int index = factory.getClassIndexMap().get(type);
String prename = names[index];
String prens = namespaces[index];
String defname = ctx.attributeText(URI_ATTRIBUTES, COMMON_NAME);
String defns = ctx.attributeText(URI_ATTRIBUTES, COMMON_NAMESPACE, prens);
if (!prename.equals(defname)) {
throw new JiBXException("Precompiled mapping for class " + type +
" uses element name '" + prename + "' which does not match element name '" +
defname + "' used in binding");
} else if (!Utility.safeEquals(prens, defns)) {
throw new JiBXException("Precompiled mapping for class " + type +
" uses element namespace '" + prens + "' which does not match element namespace '" +
defns + "' used in binding");
} else {
ndef = new NameDefinition(defname, defns, false);
}
}
// get type name and mapping name (type, or class if no type)
String mname = type;
String tname = null;
String text = ctx.attributeText(URI_ATTRIBUTES, MAPPING_TYPENAME,
null);
if (text != null) {
tname = QName.deserialize(text, ctx).toString();
mname = tname;
}
// build mapping definition to match
IMapping mapping;
if (abs) {
int index = typemap.get(mname);
if (index >= 0) {
mapping = new PrecompiledAbstractMapping(type, tname, mname,
index, factory, nsxlate, parent);
} else {
throw new IllegalStateException("Precompiled binding does not match supplied binding for " + factory.getBindingName() + ": type " + mname + " not found");
}
} else {
int index = namemap.get(type);
if (index >= 0) {
mapping = new PrecompiledConcreteMapping(mname, type, ndef,
mars[index], umars[index], parent, nsxlate != null,
factory.getClass().getName());
} else {
throw new IllegalStateException("Precompiled binding does not match supplied binding for " + factory.getBindingName() + ": class " + type + " not found");
}
}
parent.getDefinitionContext().addMapping(mapping);
ctx.skipElement();
}
// finish with any mappings without names
for (int i = names.length; i < classes.length; i++) {
String mapname = classes[i];
String typname = mapname;
int split = typname.indexOf('-');
if (split >= 0) {
typname = typname.substring(0, split);
}
IMapping mapping = new PrecompiledConcreteMapping(mapname,
typname, null, mars[i], umars[i], parent, nsxlate != null,
factory.getClass().getName());
parent.getDefinitionContext().addMapping(mapping);
}
}
/**
* Unmarshal included binding. This handles the actual include element along
* with the actual included binding. The current implementation allows for
* nested includes, but requires that all the included bindings use
* compatible settings for the attributes of the root element, and only
* allows mapping elements as children of the included bindings (no
* namespace or format elements).
*
* @param ctx unmarshalling context information
* @param precomp in precompiled bindings flag
* @param bdef binding definition at root of includes
* @param root base URL for binding, or null if unknown
* @param nslist list of namespaces defined
* @param paths set of binding paths processed
* @param factory precompiled binding factory (null if not in
* precompiled binding)
* @param nsxlate namespace translation table for precompiled binding
* (null if not in precompiled binding)
* @throws JiBXException if error in unmarshalling
*/
public static void unmarshalInclude(UnmarshallingContext ctx,
boolean precomp, BindingDefinition bdef, URL root,
ArrayList nslist, HashSet paths, IBindingFactory factory, int[] nsxlate)
throws JiBXException {
// make sure path hasn't already been processed
ctx.parseToStartTag(URI_ELEMENTS, INCLUDE_ELEMENT);
String path = ctx.attributeText(URI_ATTRIBUTES, INCLUDE_PATH);
URL url;
try {
url = ClasspathUrlExtender.buildURL(root, path);
} catch (MalformedURLException e) {
throw new JiBXException("Unable to handle include path " + path, e);
}
String fpath = url.toExternalForm();
if (paths.add(fpath)) {
try {
// access the included binding as input stream
UnmarshallingContext ictx = new UnmarshallingContext();
ictx.setDocument(url.openStream(), null);
// get basic name and package information from binding
ictx.parseToStartTag(URI_ELEMENTS, BINDING_ELEMENT);
String fname = org.jibx.binding.Utility.fileName(path);
String name = ictx.attributeText(URI_ATTRIBUTES, BINDING_NAME,
org.jibx.binding.Utility.bindingFromFileName(fname));
int major = ictx.attributeInt(URI_ATTRIBUTES,
BINDING_MAJORVER, 0);
int minor = ictx.attributeInt(URI_ATTRIBUTES,
BINDING_MINORVER, 0);
String tpack = ictx.attributeText(URI_ATTRIBUTES,
BINDING_PACKAGE, null);
boolean direct = ctx.attributeBoolean(URI_ATTRIBUTES,
INCLUDE_PRECOMPILED, false);
if (direct && tpack == null) {
throw new JiBXException("package attribute is required for precompiled binding");
}
if (direct) {
// load and add binding factory for precompiled binding
factory = BindingDirectory.getFactory(name, tpack,
ClassFile.getClassLoader());
nsxlate = bdef.addPrecompiledBinding(factory, major, minor);
}
// unmarshal namespaces (to apply to these mappings, only)
ictx.parsePastStartTag(URI_ELEMENTS, BINDING_ELEMENT);
ArrayList nss = new ArrayList(nslist);
while (ictx.isAt(URI_ELEMENTS, NAMESPACE_ELEMENT)) {
nss.add(unmarshalNamespace(ictx));
}
// process any format definitions (for global context)
precomp = precomp || direct;
unmarshalFormats(ictx, precomp, bdef.getDefinitionContext());
// check for nested includes
while (ictx.isAt(URI_ELEMENTS, INCLUDE_ELEMENT)) {
unmarshalInclude(ictx, precomp, bdef, url, nss, paths,
factory, nsxlate);
}
// process all mappings defined in included binding
if (precomp) {
unmarshalPrecompiledMappings(ictx, factory, bdef, nsxlate);
} else {
unmarshalMappings(ictx, bdef, nss, false);
}
} catch (IOException e) {
throw new JiBXException
("Error accessing included binding with path " + path + " (" + fpath + ')', e);
}
}
// finish by skipping past end of tag in main binding
ctx.parsePastEndTag(URI_ELEMENTS, INCLUDE_ELEMENT);
}
/**
* Unmarshal binding definition. This handles the entire binding definition
* document.
*
* @param ctx unmarshalling context information
* @param name default name for binding
* @param root base URL for binding, or null if unknown
* @return binding definition
* @throws JiBXException if error in unmarshalling
*/
public static BindingDefinition unmarshalBindingDefinition
(UnmarshallingContext ctx, String name, URL root)
throws JiBXException {
// start by reading optional binding name
ctx.parseToStartTag(URI_ELEMENTS, BINDING_ELEMENT);
name = ctx.attributeText(URI_ATTRIBUTES, BINDING_NAME, name);
// set the binding direction flags
int dir = ctx.attributeEnumeration(URI_ATTRIBUTES, BINDING_DIRECTION,
BINDINGDIR_NAMES, BINDINGDIR_NUMS, DIRECTION_BOTH);
boolean ibind = dir == DIRECTION_BOTH || dir == DIRECTION_INPUT;
boolean obind = dir == DIRECTION_BOTH || dir == DIRECTION_OUTPUT;
// read other attribute values
String tpack = ctx.attributeText(URI_ATTRIBUTES, BINDING_PACKAGE, null);
boolean glob = ctx.attributeBoolean(URI_ATTRIBUTES,
BINDING_GLOBALID, true);
boolean forward = ctx.attributeBoolean(URI_ATTRIBUTES,
BINDING_FORWARDS, true);
boolean track = ctx.attributeBoolean(URI_ATTRIBUTES,
BINDING_TRACKING, false);
boolean force = ctx.attributeBoolean(URI_ATTRIBUTES,
BINDING_FORCE, false);
boolean add = ctx.attributeBoolean(URI_ATTRIBUTES, BINDING_ADD, false);
boolean trim = ctx.attributeBoolean(URI_ATTRIBUTES, BINDING_TRIM, false);
int major = ctx.attributeInt(URI_ATTRIBUTES, BINDING_MAJORVER, 0);
int minor = ctx.attributeInt(URI_ATTRIBUTES, BINDING_MINORVER, 0);
// create actual binding instance
BindingDefinition bdef = new BindingDefinition(name, ibind, obind, tpack,
glob, forward, track, force, add, trim, major, minor);
bdef.unmarshal(ctx);
// unmarshal namespaces and formats defined under root
ctx.parsePastStartTag(URI_ELEMENTS, BINDING_ELEMENT);
ArrayList nss = new ArrayList();
while (ctx.isAt(URI_ELEMENTS, NAMESPACE_ELEMENT)) {
nss.add(unmarshalNamespace(ctx));
}
unmarshalFormats(ctx, false, bdef.getDefinitionContext());
// process any included binding definitions
HashSet paths = new HashSet();
if (root != null) {
paths.add(root.toExternalForm());
}
while (ctx.isAt(URI_ELEMENTS, INCLUDE_ELEMENT)) {
unmarshalInclude(ctx, false, bdef, root, nss, paths, null, null);
}
// finish with common handling for elements which can be nested
unmarshalMappings(ctx, bdef, nss, false);
ctx.parsePastEndTag(URI_ELEMENTS, BINDING_ELEMENT);
return bdef;
}
/**
* Base class for containers. This just handles unmarshalling and checking
* the values of attributes used by all containers. The container class
* should set the appropriate default values for all these attributes in its
* constructor, using -1 (for int values) and
* null (for String values) if the default is to
* simply use setting inherited from a containing component. The binding
* definition root object must always define actual values as the defaults,
* since otherwise the code will fall off the end of the chain of ancestors.
*/
/*package*/ static class ContainerBase {
/** Containing binding component. */
protected IContainer m_container;
/** Default style for value expression. */
protected int m_styleDefault;
/** Auto-link style for default mappings. */
protected int m_autoLink;
/** Access level for default mappings. */
protected int m_accessLevel;
/** Prefix text to be stripped from names. */
protected String m_stripPrefix;
/** Suffix text to be stripped from names. */
protected String m_stripSuffix;
/** Style used for generating element or attribute names. */
protected int m_nameStyle;
/**
* Constructor.
*
* @param parent containing binding definition context
*/
public ContainerBase(IContainer parent) {
m_container = parent;
}
/**
* Unmarshal common container attributes.
*
* @param ctx unmarshalling context information
* @throws JiBXException if error in unmarshalling
*/
public void unmarshal(UnmarshallingContext ctx) throws JiBXException {
m_styleDefault = ctx.attributeEnumeration(URI_ATTRIBUTES,
COMMON_STYLE, CONTAINING_STYLE_NAMES, CONTAINING_STYLE_NUMS,
m_styleDefault);
m_autoLink = ctx.attributeEnumeration(URI_ATTRIBUTES,
COMMON_AUTOLINK, AUTO_LINK_NAMES, AUTO_LINK_NUMS, m_autoLink);
m_accessLevel = ctx.attributeEnumeration(URI_ATTRIBUTES,
COMMON_ACCESSLEVEL, ACCESS_LEVEL_NAMES, ACCESS_LEVEL_NUMS,
m_accessLevel);
m_stripPrefix = ctx.attributeText(URI_ATTRIBUTES,
COMMON_STRIPPREFIX, m_stripPrefix);
m_stripSuffix = ctx.attributeText(URI_ATTRIBUTES,
COMMON_STRIPSUFFIX, m_stripSuffix);
m_nameStyle = ctx.attributeEnumeration(URI_ATTRIBUTES,
COMMON_NAMESTYLE, NAME_GENERATE_NAMES, NAME_GENERATE_NUMS,
m_nameStyle);
}
//
// IContainer interface method definitions (partial list)
public int getStyleDefault() {
if (m_styleDefault >= 0) {
return m_styleDefault;
} else {
return m_container.getStyleDefault();
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/MappingBase.java 0000644 0001750 0001750 00000023664 11062041154 025055 0 ustar twerner twerner /*
Copyright (c) 2003-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.apache.bcel.Constants;
import org.jibx.binding.classes.BoundClass;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.ContextMethodBuilder;
import org.jibx.binding.classes.ExceptionMethodBuilder;
import org.jibx.runtime.JiBXException;
/**
* Base class for mapping definitions. This is used for both normal and custom
* mappings. It handles adding the appropriate marshalling and/or unmarshalling
* interfaces and methods to the classes.
*/
public abstract class MappingBase extends LinkableBase implements IMapping
{
//
// Constants and such related to code generation.
// definitions for IMarshallable interface defined on mapped classes
protected static final String IMARSHALLABLE_INTERFACE =
"org.jibx.runtime.IMarshallable";
protected static final String MARSHALLABLE_METHODNAME = "marshal";
protected static final String MARSHALLABLE_SIGNATURE =
"(Lorg/jibx/runtime/IMarshallingContext;)V";
protected static final String GETINDEX_METHODNAME = "JiBX_getIndex";
protected static final String GETINDEX_SIGNATURE = "()I";
protected static final String GETNAME_METHODNAME = "JiBX_getName";
protected static final String GETNAME_SIGNATURE = "()Ljava/lang/String;";
protected static final String CHECKEXTENDS_METHODNAME = "isExtension";
protected static final String CHECKEXTENDS_FULLNAME =
"org.jibx.runtime.IMarshaller." + CHECKEXTENDS_METHODNAME;
protected static final String CHECKEXTENDS_SIGNATURE =
"(Ljava/lang/String;)Z";
// definitions for IUnmarshallable interface defined on mapped classes
protected static final String IUNMARSHALLABLE_INTERFACE =
"org.jibx.runtime.IUnmarshallable";
protected static final String UNMARSHALLABLE_METHODNAME = "unmarshal";
protected static final String UNMARSHALLABLE_SIGNATURE =
"(Lorg/jibx/runtime/IUnmarshallingContext;)V";
// interface implemented by unmarshaller class
protected static final String UNMARSHALLER_INTERFACE =
"org.jibx.runtime.IUnmarshaller";
protected static final String UNMARSHALLERUNMARSHAL_METHOD =
"org.jibx.runtime.IUnmarshaller.unmarshal";
protected static final String UNMARSHALLERUNMARSHAL_SIGNATURE =
"(Ljava/lang/Object;Lorg/jibx/runtime/IUnmarshallingContext;)" +
"Ljava/lang/Object;";
// interface implemented by marshaller class
protected static final String MARSHALLER_INTERFACE =
"org.jibx.runtime.IMarshaller";
protected static final String ABSTRACTMARSHALLER_INTERFACE =
"org.jibx.runtime.IAbstractMarshaller";
protected static final String MARSHALLERMARSHAL_METHOD =
"org.jibx.runtime.IMarshaller.marshal";
protected static final String MARSHALLERMARSHAL_SIGNATURE =
"(Ljava/lang/Object;Lorg/jibx/runtime/IMarshallingContext;)V";
// definitions for context methods used to find marshaller and unmarshaller
protected static final String GETMARSHALLER_METHOD =
"org.jibx.runtime.IMarshallingContext.getMarshaller";
protected static final String GETMARSHALLER_SIGNATURE =
"(Ljava/lang/String;)Lorg/jibx/runtime/IMarshaller;";
protected static final String GETUNMARSHALLER_METHOD =
"org.jibx.runtime.IUnmarshallingContext.getUnmarshaller";
protected static final String GETUNMARSHALLER_SIGNATURE =
"(Ljava/lang/String;)Lorg/jibx/runtime/IUnmarshaller;";
//
// Actual instance data.
/** Name used for mapping in binding tables. */
private final String m_mappingName;
/** Qualified type name, in text form. */
private final String m_typeName;
/**
* Constructor. This version requires the component to be set later,
* using the {@link
* org.jibx.binding.def.PassThroughComponent#setWrappedComponent} method.
*
* @param contain containing binding definition structure
* @param type class name handled by mapping
* @param tname qualified type name, in text form
*/
public MappingBase(IContainer contain, String type, String tname) {
String name = (tname == null) ? type : tname;
m_mappingName = name;
contain.getBindingRoot().addMappingName(name);
m_typeName = tname;
}
/**
* Constructor with wrapped component supplied.
*
* @param contain containing binding definition structure
* @param type class name handled by mapping
* @param tname qualified type name, in text form
* @param wrap wrapped binding component
*/
public MappingBase(IContainer contain, String type, String tname,
IComponent wrap) {
this(contain, type, tname);
setWrappedComponent(wrap);
}
/**
* Get the mapped class information. This must be implemented in each
* subclass to return the type of the bound class.
*
* @return information for mapped class
*/
public abstract BoundClass getBoundClass();
/**
* Generate marshallable interface methods for this mapping. This is not
* applicable to abstract mappings, since they cannot be marshalled as
* separate items.
*
* @throws JiBXException if error in generating code
*/
protected void addIMarshallableMethod() throws JiBXException {
// set up for constructing actual marshal method
BoundClass clas = getBoundClass();
ClassFile cf = clas.getMungedFile();
ContextMethodBuilder mb = new ContextMethodBuilder
(MARSHALLABLE_METHODNAME, MARSHALLABLE_SIGNATURE, cf,
Constants.ACC_PUBLIC, 0, clas.getClassFile().getName(),
1, MARSHALLER_INTERFACE);
// create call to marshalling context method with class name
mb.loadContext();
mb.appendLoadConstant(cf.getName());
mb.appendCallInterface(GETMARSHALLER_METHOD, GETMARSHALLER_SIGNATURE);
// call the returned marshaller with this object and the marshalling
// context as parameters
mb.loadObject();
mb.loadContext();
mb.appendCallInterface(MARSHALLERMARSHAL_METHOD,
MARSHALLERMARSHAL_SIGNATURE);
mb.appendReturn();
// add method to class
clas.getUniqueNamed(mb);
// generate and add get mapping name method
ExceptionMethodBuilder xb = new ExceptionMethodBuilder
(GETNAME_METHODNAME, GETNAME_SIGNATURE, cf, Constants.ACC_PUBLIC);
xb.appendLoadConstant(cf.getName());
xb.appendReturn("java.lang.String");
clas.getUniqueNamed(xb);
// add the interface to class
clas.getClassFile().addInterface(IMARSHALLABLE_INTERFACE);
}
/**
* Generate unmarshallable interface method for this mapping. This is not
* applicable to abstract mappings, since they cannot be unmarshalled as
* separate items.
*
* @throws JiBXException if error in generating code
*/
protected void addIUnmarshallableMethod() throws JiBXException {
// set up for constructing new method
BoundClass clas = getBoundClass();
ClassFile cf = clas.getMungedFile();
ContextMethodBuilder mb = new ContextMethodBuilder
(UNMARSHALLABLE_METHODNAME, UNMARSHALLABLE_SIGNATURE, cf,
Constants.ACC_PUBLIC, 0, clas.getClassFile().getName(),
1, UNMARSHALLER_INTERFACE);
// create call to unmarshalling context method with class name
mb.loadContext();
mb.appendLoadConstant(cf.getName());
mb.appendCallInterface(GETUNMARSHALLER_METHOD,
GETUNMARSHALLER_SIGNATURE);
// call the returned unmarshaller with this object and the unmarshalling
// context as parameters
mb.loadObject();
mb.loadContext();
mb.appendCallInterface(UNMARSHALLERUNMARSHAL_METHOD,
UNMARSHALLERUNMARSHAL_SIGNATURE);
mb.appendReturn();
// add the method to class
clas.getUniqueNamed(mb);
// generate and add get mapping name method
ExceptionMethodBuilder xb = new ExceptionMethodBuilder
(GETNAME_METHODNAME, GETNAME_SIGNATURE, cf, Constants.ACC_PUBLIC);
xb.appendLoadConstant(cf.getName());
xb.appendReturn("java.lang.String");
clas.getUniqueNamed(xb);
// add the interface to class
clas.getClassFile().addInterface(IUNMARSHALLABLE_INTERFACE);
}
//
// IMapping interface method definitions
public String getMappingName() {
return m_mappingName;
}
/* (non-Javadoc)
* @see org.jibx.binding.def.IMapping#getTypeName()
*/
public String getTypeName() {
return m_typeName;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/PropertyDefinition.java 0000644 0001750 0001750 00000066637 11475460660 026552 0 ustar twerner twerner /*
Copyright (c) 2003-2010, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import java.util.ArrayList;
import org.jibx.binding.classes.BranchWrapper;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.ClassItem;
import org.jibx.binding.classes.ContextMethodBuilder;
import org.jibx.binding.classes.MethodBuilder;
import org.jibx.binding.model.ClassUtils;
import org.jibx.binding.util.IntegerCache;
import org.jibx.runtime.JiBXException;
/**
* Property definition from binding. This organizes shared information for
* bindings linked to fields or get/set methods of an object, and provides
* methods for related code generation.
*
* @author Dennis M. Sosnoski
*/
public class PropertyDefinition
{
//
// Constants and such related to code generation.
// recognized test-method signatures.
private static final String[] TEST_METHOD_SIGNATURES =
{
"(Lorg/jibx/runtime/IMarshallingContext;)Z",
"()Z"
};
// recognized get-method signatures.
private static final String[] GET_METHOD_SIGNATURES =
{
"(Lorg/jibx/runtime/IMarshallingContext;)",
"()"
};
// recognized flag-method signatures.
private static final String[] FLAG_METHOD_SIGNATURES =
{
"(ZLorg/jibx/runtime/IMarshallingContext;)",
"(Z)"
};
//
// Actual instance data
/** Reference to "this" property of object flag. */
private boolean m_isThis;
/** Reference to implicit value from collection. */
private boolean m_isImplicit;
/** Optional item flag. */
private boolean m_isOptional;
/** Containing object context. */
private final IContextObj m_objContext;
/** Fully qualified name of actual type of value. */
private final String m_typeName;
/** Fully qualified name of declared type of value loaded. */
private final String m_getValueType;
/** Fully qualified name of declared type of value stored. */
private final String m_setValueType;
/** Information for field (if given, may be null). */
private final ClassItem m_fieldItem;
/** Information for test method (if given, may be null). */
private final ClassItem m_testMethod;
/** Information for flag method (if given, may be null). */
private final ClassItem m_flagMethod;
/** Information for get method (if given, may be null). */
private final ClassItem m_getMethod;
/** Information for set method (if given, may be null). */
private final ClassItem m_setMethod;
/**
* Constructor.
*
* @param parent containing binding definition structure
* @param obj containing object context
* @param type fully qualified name of type
* @param isthis "this" object reference flag
* @param opt optional property flag
* @param fname containing object field name for property (may be
* null)
* @param test containing object method to test for property present (may be
* null)
* @param flag containing object method to flag property present (may be
* null)
* @param get containing object method to get property value (may be
* null)
* @param set containing object method to set property value (may be
* null)
* @throws JiBXException if configuration error
*/
public PropertyDefinition(IContainer parent, IContextObj obj, String type,
boolean isthis, boolean opt, String fname, String test, String flag,
String get, String set) throws JiBXException {
m_objContext = obj;
m_isThis = isthis;
m_isOptional = opt;
ClassFile cf = m_objContext.getBoundClass().getClassFile();
m_isImplicit = false;
String dtype = null;
String gtype = null;
String stype = null;
if (isthis) {
if (type == null) {
dtype = gtype = stype = cf.getName();
} else {
dtype = gtype = stype = type;
}
}
if (fname == null) {
m_fieldItem = null;
} else {
m_fieldItem = cf.getField(fname);
dtype = gtype = stype = m_fieldItem.getTypeName();
}
if (test == null) {
m_testMethod = null;
} else {
m_testMethod = cf.getMethod(test, TEST_METHOD_SIGNATURES);
if (m_testMethod == null) {
throw new JiBXException("test-method " + test +
" not found in class " + cf.getName());
}
}
if (get == null) {
m_getMethod = null;
} else {
m_getMethod = cf.getMethod(get, GET_METHOD_SIGNATURES);
if (m_getMethod == null) {
throw new JiBXException("get-method " + get +
" not found in class " + cf.getName());
} else {
gtype = m_getMethod.getTypeName();
if (dtype == null) {
dtype = gtype;
}
}
}
if (set == null) {
m_setMethod = null;
} else {
// need to handle overloads, so generate possible signatures
ArrayList sigs = new ArrayList();
if (m_getMethod != null) {
String psig = ClassUtils.getSignature(gtype);
sigs.add("(" + psig +
"Lorg/jibx/runtime/IUnmarshallingContext;" + ")V");
sigs.add("(" + psig + ")V");
}
if (type != null) {
String psig = ClassUtils.getSignature(type);
sigs.add("(" + psig +
"Lorg/jibx/runtime/IUnmarshallingContext;" + ")V");
sigs.add("(" + psig + ")V");
}
if (m_fieldItem != null) {
String psig = m_fieldItem.getSignature();
sigs.add("(" + psig +
"Lorg/jibx/runtime/IUnmarshallingContext;" + ")V");
sigs.add("(" + psig + ")V");
}
sigs.add
("(Ljava/lang/Object;Lorg/jibx/runtime/IUnmarshallingContext;)V");
sigs.add("(Ljava/lang/Object;)V");
// set method needs verification of argument and return type
ClassItem setmeth = cf.getMethod(set,
(String[])sigs.toArray(new String[0]));
if (setmeth == null) {
// nothing known about signature, try anything by name
setmeth = cf.getMethod(set, "");
if (setmeth != null) {
if (!setmeth.getTypeName().equals("void") ||
setmeth.getArgumentCount() > 2) {
setmeth = null;
} else if (setmeth.getArgumentCount() == 2) {
String xtype = setmeth.getArgumentType(1);
if (!"org.jibx.runtime.IUnmarshallingContext".equals(xtype)) {
setmeth = null;
}
}
}
}
// check if method found
m_setMethod = setmeth;
if (m_setMethod == null) {
throw new JiBXException("set-method " + set +
" not found in class " + cf.getName());
} else {
stype = m_setMethod.getArgumentType(0);
if (dtype == null) {
dtype = stype;
}
}
}
if (flag == null) {
m_flagMethod = null;
} else {
m_flagMethod = cf.getMethod(flag, FLAG_METHOD_SIGNATURES);
if (m_flagMethod == null) {
throw new JiBXException("flag-method " + flag +
" not found in class " + cf.getName());
} else if (stype == null) {
stype = "java.lang.String";
if (dtype == null) {
dtype = stype;
}
}
}
if (gtype == null) {
gtype = "java.lang.Object";
}
m_getValueType = gtype;
m_setValueType = stype;
// check that enough information is supplied
BindingDefinition root = parent.getBindingRoot();
if (!isthis && m_fieldItem == null) {
if (root.isInput() && m_setMethod == null && m_flagMethod == null) {
throw new JiBXException
("Missing way to set value for input binding");
}
if (root.isOutput() && m_getMethod == null &&
(m_flagMethod == null || m_testMethod == null)) {
throw new JiBXException
("Missing way to get value for output binding");
}
}
// check that type information is consistent
if (type == null) {
m_typeName = dtype;
} else {
m_typeName = type;
boolean valid = true;
if (isthis) {
valid = ClassItem.isAssignable(dtype, type);
} else {
if (root.isInput()) {
valid = ClassItem.isAssignable(type, m_setValueType) ||
ClassItem.isAssignable(m_setValueType, type);
}
if (valid && root.isOutput()) {
valid = ClassItem.isAssignable(type, m_getValueType) ||
ClassItem.isAssignable(m_getValueType, type);
}
}
if (!valid) {
throw new JiBXException
("Incompatible types for property definition");
}
}
}
/**
* Constructor for "this" object reference.
*
* @param obj containing object context
* @param opt optional property flag
*/
public PropertyDefinition(IContextObj obj, boolean opt) {
m_objContext = obj;
m_isThis = true;
m_isImplicit = false;
m_isOptional = opt;
ClassFile cf = m_objContext.getBoundClass().getClassFile();
m_fieldItem = m_testMethod = m_flagMethod = m_getMethod = m_setMethod = null;
m_typeName = m_getValueType = m_setValueType = cf.getName();
}
/**
* Constructor for implicit object reference.
*
* @param type object type supplied
* @param obj containing object context
* @param opt optional property flag
*/
public PropertyDefinition(String type, IContextObj obj, boolean opt) {
m_objContext = obj;
m_isImplicit = true;
m_isThis = false;
m_isOptional = opt;
m_fieldItem = m_testMethod = m_flagMethod = m_getMethod = m_setMethod = null;
m_typeName = m_getValueType = m_setValueType = type;
}
/**
* Copy constructor.
*
* @param original
*/
public PropertyDefinition(PropertyDefinition original) {
m_isThis = original.m_isThis;
m_isImplicit = original.m_isImplicit;
m_isOptional = original.m_isOptional;
m_objContext = original.m_objContext;
m_typeName = original.m_typeName;
m_getValueType = original.m_getValueType;
m_setValueType = original.m_setValueType;
m_fieldItem = original.m_fieldItem;
m_testMethod = original.m_testMethod;
m_flagMethod = original.m_flagMethod;
m_getMethod = original.m_getMethod;
m_setMethod = original.m_setMethod;
}
/**
* Check if property is "this" reference for object.
*
* @return true if reference to "this", false if
* not
*/
public boolean isThis() {
return m_isThis;
}
/**
* Check if property is implicit value from collection.
*
* @return true if implicit, false if not
*/
public boolean isImplicit() {
return m_isImplicit;
}
/**
* Switch property from "this" to "implicit".
*/
public void switchProperty() {
m_isThis = false;
m_isImplicit = true;
}
/**
* Check if property is optional.
*
* @return true if optional, false if required
*/
public boolean isOptional() {
return m_isOptional;
}
/**
* Set flag for an optional property.
*
* @param opt true if optional property, false if
* not
*/
public void setOptional(boolean opt) {
m_isOptional = opt;
}
/**
* Check if the value can be loaded.
*
* @return true if loadable, false if not
*/
public boolean isLoadable() {
return m_getMethod != null || m_fieldItem != null;
}
/**
* Get property name. If a field is defined this is the same as the field;
* otherwise it is either the get method name (with leading "get" stripped,
* if present) or the set method (with leading "set" stripped, if present),
* whichever is found.
*
* @return name for this property
*/
public String getName() {
if (m_isThis) {
return "this";
} else if (m_fieldItem != null) {
return m_fieldItem.getName();
} else if (m_getMethod != null) {
String name = m_getMethod.getName();
if (name.startsWith("get") && name.length() > 3) {
name = name.substring(3);
}
return name;
} else if (m_setMethod != null) {
String name = m_setMethod.getName();
if (name.startsWith("set") && name.length() > 3) {
name = name.substring(3);
}
return name;
} else {
return "item";
}
}
/**
* Get declared type fully qualified name.
*
* @return fully qualified class name of declared type
*/
public String getTypeName() {
return m_typeName;
}
/**
* Get value type as fully qualified name for loaded property value.
*
* @return fully qualified class name of value type
*/
public String getGetValueType() {
return m_getValueType;
}
/**
* Get value type as fully qualified name for stored property value.
*
* @return fully qualified class name of value type
*/
public String getSetValueType() {
return m_setValueType;
}
/**
* Check if property has presence test. Code needs to be generated to check
* for the presence of the property if it is optional and either a test
* method is defined or the value is an object reference.
*
* @return true if presence test needed, false if
* not
*/
public boolean hasTest() {
return isOptional() && !isImplicit() &&
(m_testMethod != null || !ClassItem.isPrimitive(m_typeName));
}
/**
* Check if property is test only.
*
* @return true if test-only property, false if
* not
*/
public boolean isTestOnly() {
return m_testMethod != null && m_getMethod == null &&
m_fieldItem == null;
}
/**
* Check if property has flag method.
*
* @return true if flag method defined, false if
* not
*/
public boolean hasFlag() {
return m_flagMethod != null;
}
/**
* Check if property is flag only.
*
* @return true if flag-only property, false if
* not
*/
public boolean isFlagOnly() {
return m_flagMethod != null && m_getMethod == null &&
m_fieldItem == null;
}
/**
* Append instruction to duplicate the value on the stack. This will use the
* appropriate instruction for the size of the value.
*
* @param mb
*/
private void duplicateValue(MethodBuilder mb) {
if ("long".equals(m_typeName) || "double".equals(m_typeName)) {
mb.appendDUP2();
} else {
mb.appendDUP();
}
}
/**
* Append instruction to pop the value from the stack. This will use the
* appropriate instruction for the size of the value.
*
* @param mb
*/
private void discardValue(MethodBuilder mb) {
if ("long".equals(m_typeName) || "double".equals(m_typeName)) {
mb.appendPOP2();
} else {
mb.appendPOP();
}
}
/**
* Generate code to test if property is present. The generated code
* assumes that the top of the stack is the reference for the containing
* object, and consumes this value for the test. The target for the
* returned branch instruction must be set by the caller.
*
* @param mb method builder
* @return wrapper for branch instruction taken when property is missing
*/
public BranchWrapper genTest(ContextMethodBuilder mb) {
// first check for supplied test method
if (m_testMethod != null) {
// generate call to test method to check for property present
mb.addMethodExceptions(m_testMethod);
if (m_testMethod.isStatic()) {
discardValue(mb);
}
if (m_testMethod.getArgumentCount() > 0) {
mb.loadContext();
}
mb.appendCall(m_testMethod);
return mb.appendIFEQ(this);
} else if (!ClassItem.isPrimitive(m_typeName) && !m_isImplicit) {
if (!m_isThis) {
// generated instruction either loads a field value or calls a
// "get" method, as appropriate
if (m_getMethod == null) {
if (m_fieldItem.isStatic()) {
discardValue(mb);
}
mb.appendGet(m_fieldItem);
} else {
if (m_getMethod.isStatic()) {
discardValue(mb);
}
if (m_getMethod.getArgumentCount() > 0) {
mb.loadContext();
}
mb.addMethodExceptions(m_getMethod);
mb.appendCall(m_getMethod);
}
}
return mb.appendIFNULL(this);
} else {
return null;
}
}
/**
* Generate code to call flag method with value on stack. The generated code
* assumes that the reference to the containing object and the value to be
* stored have already been pushed on the stack. It consumes these, leaving
* nothing. If the property value is not directly accessible from the
* context of the method being generated this automatically constructs an
* access method and uses that method.
*
* @param mb method builder
* @throws JiBXException if configuration error
*/
public void genFlag(MethodBuilder mb) throws JiBXException {
// first check direct access to property from method class
ClassFile from = mb.getClassFile();
ClassItem access = m_flagMethod;
if (!from.isAccessible(access)) {
access = m_objContext.getBoundClass().
getStoreMethod(access, mb.getClassFile());
}
// generated instruction calls the "flag" method
if (access.isMethod()) {
if (access.getArgumentCount() > 1) {
((ContextMethodBuilder)mb).loadContext();
}
mb.addMethodExceptions(access);
mb.appendCall(access);
}
if (access.isStatic()) {
discardValue(mb);
}
}
/**
* Generate code to load property value to stack. The generated code
* assumes that the top of the stack is the reference for the containing
* object. It consumes this and leaves the actual value on the stack. If
* the property value is not directly accessible from the context of the
* method being generated this automatically constructs an access method
* and uses that method.
*
* @param mb method builder
* @throws JiBXException if configuration error
*/
public void genLoad(ContextMethodBuilder mb) throws JiBXException {
// nothing to be done if called on "this" or implicit reference
if (!m_isThis && !m_isImplicit) {
// first check direct access to property from method class
ClassFile from = mb.getClassFile();
ClassItem access = m_getMethod;
if (access == null) {
access = m_fieldItem;
}
if (access != null && !from.isAccessible(access)) {
access = m_objContext.getBoundClass().
getLoadMethod(access, mb.getClassFile());
}
// generated instruction either loads a field value or calls a "get"
// method, as appropriate
if (access == null) {
Integer index = (Integer)mb.getKeyValue(this);
discardValue(mb);
if (index == null) {
mb.appendACONST_NULL();
} else {
mb.appendLoadLocal(index.intValue());
}
} else {
if (access.isStatic()) {
discardValue(mb);
}
if (access.isMethod()) {
if (access.getArgumentCount() > 0) {
mb.loadContext();
}
mb.addMethodExceptions(access);
mb.appendCall(access);
} else {
mb.appendGet(access);
}
}
// cast value if necessary to assure correct type
mb.appendCreateCast(m_getValueType, m_typeName);
}
}
/**
* Generate code to store property value from stack. The generated code
* assumes that the reference to the containing object and the value to be
* stored have already been pushed on the stack. It consumes these, leaving
* nothing. If the property value is not directly accessible from the
* context of the method being generated this automatically constructs an
* access method and uses that method.
*
* @param mb method builder
* @throws JiBXException if configuration error
*/
public void genStore(MethodBuilder mb) throws JiBXException {
// ignore call if no way of setting value
if (!m_isThis && !m_isImplicit && m_fieldItem == null &&
m_setMethod == null) {
mb.appendPOP();
mb.appendPOP();
} else {
// check for cast needed to convert to actual type
if (!ClassItem.isPrimitive(m_setValueType)) {
mb.appendCreateCast(m_setValueType);
}
// nothing to be done if called on "this" or implicit reference
if (!m_isThis && !m_isImplicit) {
// first check direct access to property from method class
ClassFile from = mb.getClassFile();
ClassItem access = m_setMethod;
if (access == null) {
access = m_fieldItem;
}
if (!from.isAccessible(access)) {
access = m_objContext.getBoundClass().
getStoreMethod(access, mb.getClassFile());
}
// save to local if no way of getting value
if (m_getMethod == null && m_fieldItem == null) {
duplicateValue(mb);
Integer index = (Integer)mb.getKeyValue(this);
if (index == null) {
int slot = mb.addLocal(null,
ClassItem.typeFromName(m_setValueType));
index = IntegerCache.getInteger(slot);
mb.setKeyValue(this, index);
} else {
mb.appendStoreLocal(index.intValue());
}
}
// generated instruction either stores a field value or calls a
// "set" method, as appropriate
if (access.isMethod()) {
if (access.getArgumentCount() > 1) {
// this test is ugly, needed because of backfill method
// calls from ValueChild
if (mb instanceof ContextMethodBuilder) {
((ContextMethodBuilder)mb).loadContext();
} else {
mb.appendACONST_NULL();
}
}
mb.addMethodExceptions(access);
mb.appendCall(access);
} else {
mb.appendPut(access);
}
if (access.isStatic()) {
discardValue(mb);
}
}
}
}
// DEBUG
public String toString() {
StringBuffer text = new StringBuffer();
if (m_isOptional) {
text.append("optional ");
}
text.append("property ");
if (m_isThis) {
text.append("\"this\" ");
} else if (m_isImplicit) {
text.append("from collection ");
} else if (m_fieldItem != null) {
text.append(m_fieldItem.getName() + " ");
} else {
if (m_getMethod != null) {
text.append("from " + m_getMethod.getName() + " ");
}
if (m_setMethod != null) {
text.append("to " + m_setMethod.getName() + " ");
}
}
if (m_flagMethod != null) {
text.append("flag " + m_flagMethod.getName() + " ");
}
if (m_testMethod != null) {
text.append("test " + m_testMethod.getName() + " ");
}
if (m_typeName != null) {
text.append( "("+ m_typeName + ")");
}
return text.toString();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/DirectObject.java 0000644 0001750 0001750 00000057250 11357624722 025245 0 ustar twerner twerner /*
Copyright (c) 2003-2010, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.apache.bcel.Constants;
import org.apache.bcel.generic.Type;
import org.jibx.binding.classes.*;
import org.jibx.runtime.JiBXException;
/**
* Linkage to object with supplied marshaller and unmarshaller. This provides
* methods used to generate code for calling the supplied classes.
*
* @author Dennis M. Sosnoski
*/
public class DirectObject implements IComponent
{
//
// Constants and such related to code generation.
private static final String GETUNMARSHALLER_METHOD =
"org.jibx.runtime.IUnmarshallingContext.getUnmarshaller";
private static final String GETUNMARSHALLER_SIGNATURE =
"(Ljava/lang/String;)Lorg/jibx/runtime/IUnmarshaller;";
private static final String GETMARSHALLER_METHOD =
"org.jibx.runtime.IMarshallingContext.getMarshaller";
private static final String GETMARSHALLER_SIGNATURE =
"(Ljava/lang/String;)Lorg/jibx/runtime/IMarshaller;";
private static final String MARSHALLER_MARSHAL_METHOD =
"org.jibx.runtime.IMarshaller.marshal";
private static final String MARSHALLER_MARSHAL_SIGNATURE =
"(Ljava/lang/Object;Lorg/jibx/runtime/IMarshallingContext;)V";
private static final String UNMARSHALLER_TESTPRESENT_METHOD =
"org.jibx.runtime.IUnmarshaller.isPresent";
private static final String UNMARSHALLER_TESTPRESENT_SIGNATURE =
"(Lorg/jibx/runtime/IUnmarshallingContext;)Z";
private static final String UNMARSHALLER_UNMARSHAL_METHOD =
"org.jibx.runtime.IUnmarshaller.unmarshal";
private static final String UNMARSHALLER_UNMARSHAL_SIGNATURE =
"(Ljava/lang/Object;Lorg/jibx/runtime/IUnmarshallingContext;)" +
"Ljava/lang/Object;";
private static final String ABSTRACTMARSHALLER_INTERFACE =
"org.jibx.runtime.IAbstractMarshaller";
private static final String ABSTRACTMARSHAL_METHOD =
"org.jibx.runtime.IAbstractMarshaller.baseMarshal";
private static final String ABSTRACTMARSHAL_SIGNATURE =
MARSHALLER_MARSHAL_SIGNATURE;
private static final String ALIASABLE_INTERFACETYPE =
"Lorg/jibx/runtime/IAliasable;";
private static final String ANY_INIT_SIG = "()V";
private static final String ANY_INITCLASS_SIG = "(Ljava/lang/String;)V";
private static final String MARSHALUNMARSHAL_INIT_SIG =
"(Ljava/lang/String;ILjava/lang/String;)V";
private static final String MARSHALONLY_INIT_SIG = "(ILjava/lang/String;)V";
private static final String UNMARSHALONLY_INIT_SIG =
"(Ljava/lang/String;Ljava/lang/String;)V";
private static final String MARSHALUNMARSHAL_INITCLASS_SIG =
"(Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V";
private static final String MARSHALONLY_INITCLASS_SIG =
"(ILjava/lang/String;Ljava/lang/String;)V";
private static final String UNMARSHALONLY_INITCLASS_SIG =
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V";
private static final String PUSH_NAMESPACES_METHOD =
"org.jibx.runtime.IMarshallingContext.pushNamespaces";
private static final String PUSH_NAMESPACES_SIG =
"(Ljava/lang/String;)V";
private static final String POP_NAMESPACES_METHOD =
"org.jibx.runtime.IMarshallingContext.popNamespaces";
private static final String POP_NAMESPACES_SIG = "()V";
//
// Actual instance data.
/** Containing binding definition structure. */
private final IContainer m_parent;
/** Definition context for resolving names. */
private final DefinitionContext m_defContext;
/** Abstract mapping flag. If this is set the marshalling code will call the
special interface method used to verify the type of a passed object and
marshal it with the proper handling. */
private final boolean m_isAbstract;
/** Element name information (null if no bound element). */
private final NameDefinition m_name;
/** Class handled by this binding. */
private final ClassFile m_targetClass;
/** Marshaller base class. */
private final ClassFile m_marshallerBase;
/** Unmarshaller base class. */
private final ClassFile m_unmarshallerBase;
/** Mapping name supplied flag. */
private final boolean m_fixedName;
/** Binding factory name used for activating namespace translation on
marshalling (null if translation not required). */
private final String m_factoryName;
/** Marshaller class (lazy create on first use if name supplied). */
private ClassFile m_marshaller;
/** Unmarshaller class (lazy create on first use if name supplied). */
private ClassFile m_unmarshaller;
/** Name used for the mapping in binding tables. */
private String m_mappingName;
/**
* Constructor.
*
* @param parent containing binding definition structure
* @param defc active definitions context
* @param target class handled by this binding
* @param abs abstract mapping flag
* @param mcf marshaller class information (null if input only
* binding)
* @param ucf unmarshaller class information (null if output
* only binding)
* @param mapname mapping name in binding definition tables
* (null if to be constructed)
* @param name element name information (null if no element
* name)
* @param factname binding factory name for marshalling namespace
* translation (null if no namespace translation)
* @throws JiBXException if configuration error
*/
public DirectObject(IContainer parent, DefinitionContext defc,
ClassFile target, boolean abs, ClassFile mcf, ClassFile ucf,
String mapname, NameDefinition name, String factname)
throws JiBXException {
// initialize the basic information
m_parent = parent;
m_defContext = (defc == null) ? m_parent.getDefinitionContext() : defc;
m_isAbstract = abs;
m_targetClass = target;
m_marshallerBase = mcf;
m_unmarshallerBase = ucf;
m_name = name;
m_fixedName = mapname != null;
m_mappingName = mapname;
m_factoryName = factname;
// check for marshaller and/or unmarshaller configuration valid
if (name == null) {
// no name, make sure there's an appropriate constructor
if (mcf != null) {
if (mcf.getInitializerMethod(ANY_INIT_SIG) != null) {
m_marshaller = mcf;
} else if (mcf.getInitializerMethod
(ANY_INITCLASS_SIG) == null) {
throw new JiBXException("Marshaller class " +
mcf.getName() + " requires name to be set");
}
}
if (ucf != null) {
if (ucf.getInitializerMethod(ANY_INIT_SIG) != null) {
m_unmarshaller = ucf;
} else if (ucf.getInitializerMethod
(ANY_INITCLASS_SIG) == null) {
throw new JiBXException("Unmarshaller class " +
ucf.getName() + " requires name to be set");
}
}
}
if (name != null) {
// name supplied, make sure both support it
if (mcf != null && !mcf.isImplements(ALIASABLE_INTERFACETYPE)) {
throw new JiBXException("Marshaller class " +
mcf.getName() + " does not allow name to be set");
}
if (ucf != null && !ucf.isImplements(ALIASABLE_INTERFACETYPE)) {
throw new JiBXException("Unmarshaller class " +
ucf.getName() + " does not allow name to be set");
}
}
}
/**
* Load name used to identify mapping in binding tables.
*
* @param mb method builder
*/
private void genLoadName(ContextMethodBuilder mb) throws JiBXException {
if (m_mappingName == null) {
// first set name in case called recursively
BindingDefinition bdef = m_parent.getBindingRoot();
m_mappingName =
bdef.getMarshallerUnmarshallerName(m_targetClass.getName());
// now generate the classes (if needed) and set the names
String mclas = null;
String uclas = null;
if (bdef.isOutput()) {
if (m_marshaller == null) {
createSubclass(true);
}
mclas = m_marshaller.getName();
}
if (bdef.isInput()) {
if (m_unmarshaller == null) {
createSubclass(false);
}
uclas = m_unmarshaller.getName();
}
bdef.setMarshallerUnmarshallerClasses(m_mappingName, mclas, uclas);
}
mb.appendLoadConstant(m_mappingName);
}
/**
* Create aliased subclass for marshaller or unmarshaller with element name
* defined by binding. If the same aliasable superclass is defined for use
* as both a marshaller and an unmarshaller a single subclass is generated
* to handle both uses.
*
* @param out true if alias needed for marshalling,
* false if for unmarshalling
* @throws JiBXException on configuration error
*/
private void createSubclass(boolean out) throws JiBXException {
// find initializer call to be used
ClassItem init = null;
boolean dual = false;
boolean classed = true;
boolean named = false;
ClassFile base = out ? m_marshallerBase : m_unmarshallerBase;
// check for name supplied
if (m_name == null) {
init = base.getInitializerMethod(ANY_INITCLASS_SIG);
classed = init != null;
}
if (init == null) {
named = true;
if (m_unmarshallerBase == m_marshallerBase) {
// single class, look first for signature with class name
init = base.getInitializerMethod
(MARSHALUNMARSHAL_INITCLASS_SIG);
if (init == null) {
classed = false;
init = base.getInitializerMethod(MARSHALUNMARSHAL_INIT_SIG);
}
dual = true;
} else {
// using only one function, first check one way with class name
String sig = out ?
MARSHALONLY_INITCLASS_SIG : UNMARSHALONLY_INITCLASS_SIG;
init = base.getInitializerMethod(sig);
if (init == null) {
// now check dual function with class name
sig = MARSHALUNMARSHAL_INITCLASS_SIG;
init = base.getInitializerMethod(sig);
dual = true;
if (init == null) {
// now try alternatives without class name included
classed = false;
sig = out ? MARSHALONLY_INIT_SIG :
UNMARSHALONLY_INIT_SIG;
init = base.getInitializerMethod(sig);
dual = false;
if (init == null) {
sig = MARSHALUNMARSHAL_INIT_SIG;
init = base.getInitializerMethod(sig);
dual = true;
}
}
}
}
}
// make sure the initializer is defined and public
if (init == null || ((init.getAccessFlags() &
Constants.ACC_PUBLIC) == 0)) {
throw new JiBXException("No usable constructor for " +
"marshaller or unmarshaller based on " + base.getName());
}
// get package and target name from bound class
String tname = base.getName();
int split = tname.lastIndexOf('.');
if (split >= 0) {
tname = tname.substring(split+1);
}
// create the helper class
BindingDefinition def = m_parent.getBindingRoot();
String pack = def.getDefaultPackage();
if (pack.length() > 0) {
pack += '.';
}
String suffix = "";
if (!m_fixedName) {
split = m_mappingName.lastIndexOf('.') + 1;
StringBuffer buff =
new StringBuffer(m_mappingName.substring(split));
for (int i = 0; i < buff.length(); i++) {
char chr = buff.charAt(i);
if ((i == 0 && !Character.isJavaIdentifierStart(chr)) ||
!Character.isJavaIdentifierPart(chr)) {
buff.setCharAt(i, '_');
}
suffix = buff.toString();
}
suffix = m_mappingName.substring(split).replace('-', '_').
replace('[', '_').replace(']', '_');
}
String name = pack + def.getPrefix() + tname + suffix;
String[] intfs = def.isInput() ? (def.isOutput() ?
MappingDefinition.BOTH_INTERFACES :
MappingDefinition.UNMARSHALLER_INTERFACES) :
MappingDefinition.MARSHALLER_INTERFACES;
ClassFile cf = new ClassFile(name, def.getDefaultRoot(),
base, Constants.ACC_PUBLIC, intfs);
// add the public constructor method
ExceptionMethodBuilder mb = new ExceptionMethodBuilder("",
Type.VOID, new Type[0], cf, Constants.ACC_PUBLIC);
// call the superclass constructor
mb.appendLoadLocal(0);
if (m_name == null) {
if (named) {
if (dual) {
mb.appendACONST_NULL();
mb.appendICONST_0();
mb.appendACONST_NULL();
} else if (out) {
mb.appendICONST_0();
mb.appendACONST_NULL();
} else {
mb.appendACONST_NULL();
mb.appendACONST_NULL();
}
}
} else {
if (dual) {
m_name.genPushUri(mb);
m_name.genPushIndexPair(mb);
} else if (out) {
m_name.genPushIndexPair(mb);
} else {
m_name.genPushUriPair(mb);
}
}
if (classed) {
mb.appendLoadConstant(m_targetClass.getName());
}
mb.appendCallInit(base.getName(), init.getSignature());
// finish with return
mb.appendReturn();
mb.codeComplete(false);
// add method and class
mb.addMethod();
cf = MungedClass.getUniqueSupportClass(cf);
// save as appropriate type(s)
if (dual) {
m_marshaller = m_unmarshaller = cf;
} else if (out) {
m_marshaller = cf;
} else {
m_unmarshaller = cf;
}
}
/**
* Generate presence test code for this mapping. The generated code finds
* the unmarshaller and calls the test method, leaving the result on the
* stack.
*
* @param mb method builder
* @throws JiBXException if error in generating code
*/
public void genTestPresent(ContextMethodBuilder mb) throws JiBXException {
// start with call to unmarshalling context method to get the
// unmarshaller instance
mb.loadContext();
genLoadName(mb);
mb.appendCallInterface(GETUNMARSHALLER_METHOD,
GETUNMARSHALLER_SIGNATURE);
// call the actual unmarshaller test method with context as argument
mb.loadContext();
mb.appendCallInterface(UNMARSHALLER_TESTPRESENT_METHOD,
UNMARSHALLER_TESTPRESENT_SIGNATURE);
}
/**
* Generate unmarshalling code for this mapping. The generated code finds
* and calls the unmarshaller with the object to be unmarshaller (which
* needs to be loaded on the stack by the code prior to this call, but may
* be null). The unmarshalled object (or null in
* the case of a missing optional item) is left on the stack after this
* call. The calling method generally needs to cast this object reference to
* the appropriate type before using it.
*
* @param mb method builder
* @throws JiBXException if error in generating code
*/
public void genUnmarshal(ContextMethodBuilder mb) throws JiBXException {
// start with call to unmarshalling context method to get the
// unmarshaller instance
mb.loadContext();
genLoadName(mb);
mb.appendCallInterface(GETUNMARSHALLER_METHOD,
GETUNMARSHALLER_SIGNATURE);
// call the actual unmarshaller with object and context as arguments
mb.appendSWAP();
mb.loadContext();
mb.appendCallInterface(UNMARSHALLER_UNMARSHAL_METHOD,
UNMARSHALLER_UNMARSHAL_SIGNATURE);
}
/**
* Generate marshalling code for this mapping. The generated code finds
* and calls the marshaller, passing the object to be marshalled (which
* should have been loaded to the stack by the prior generated code)..
*
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public void genMarshal(ContextMethodBuilder mb) throws JiBXException {
// start by pushing namespace translation, if needed
if (m_factoryName != null) {
mb.loadContext();
mb.appendLoadConstant(m_factoryName);
mb.appendCallInterface(PUSH_NAMESPACES_METHOD,
PUSH_NAMESPACES_SIG);
}
// generate call to marshalling context method to get the marshaller
// instance
mb.loadContext();
genLoadName(mb);
mb.appendCallInterface(GETMARSHALLER_METHOD, GETMARSHALLER_SIGNATURE);
// check for an abstract mapping being used
if (m_isAbstract) {
// make sure returned marshaller implements required interface
mb.appendCreateCast(ABSTRACTMARSHALLER_INTERFACE);
// swap to reorder object and marshaller
mb.appendSWAP();
// call indirect marshaller for abstract base class with the object
// itself and context as arguments
mb.loadContext();
mb.appendCallInterface(ABSTRACTMARSHAL_METHOD,
ABSTRACTMARSHAL_SIGNATURE);
} else {
// swap to reorder object and marshaller
mb.appendSWAP();
// call the direct marshaller with the object itself and context as
// arguments
mb.loadContext();
mb.appendCallInterface(MARSHALLER_MARSHAL_METHOD,
MARSHALLER_MARSHAL_SIGNATURE);
}
// finish by popping namespace translation, if used
if (m_factoryName != null) {
mb.loadContext();
mb.appendCallInterface(POP_NAMESPACES_METHOD,
POP_NAMESPACES_SIG);
}
}
/**
* Get target class for mapping.
*
* @return target class information
*/
public ClassFile getTargetClass() {
return m_targetClass;
}
/**
* Get marshaller class used for mapping. If a name has been supplied the
* actual marshaller class is created by extending the base class the first
* time this method is called.
*
* @return marshaller class information
* @throws JiBXException if error in transformation
*/
public ClassFile getMarshaller() throws JiBXException {
if (m_marshaller == null && m_marshallerBase != null) {
createSubclass(true);
}
return m_marshaller;
}
/**
* Get unmarshaller class used for mapping. If a name has been supplied the
* actual unmarshaller class is created by extending the base class the
* first time this method is called.
*
* @return unmarshaller class information
* @throws JiBXException if error in transformation
*/
public ClassFile getUnmarshaller() throws JiBXException {
if (m_unmarshaller == null && m_unmarshallerBase != null) {
createSubclass(false);
}
return m_unmarshaller;
}
//
// IComponent interface method definitions
public boolean isOptional() {
return false;
}
public boolean hasAttribute() {
return false;
}
public void genAttrPresentTest(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no attributes defined");
}
public void genAttributeUnmarshal(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no attributes defined");
}
public void genAttributeMarshal(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no attributes defined");
}
public boolean hasContent() {
return true;
}
public void genContentPresentTest(ContextMethodBuilder mb)
throws JiBXException {
genTestPresent(mb);
}
public void genContentUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
genUnmarshal(mb);
}
public void genContentMarshal(ContextMethodBuilder mb)
throws JiBXException {
genMarshal(mb);
}
public void genNewInstance(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no instance creation");
}
public String getType() {
return m_targetClass.getFile().getName();
}
public boolean hasId() {
return false;
}
public void genLoadId(ContextMethodBuilder mb) {
throw new IllegalStateException("Internal error - no ID allowed");
}
public NameDefinition getWrapperName() {
return m_name;
}
public void setLinkages() throws JiBXException {
if (m_name != null) {
m_name.fixNamespace(m_defContext);
}
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.println("direct marshaller/unmarshaller reference" );
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/IComponent.java 0000644 0001750 0001750 00000017013 11032774170 024741 0 ustar twerner twerner /*
Copyright (c) 2003-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.jibx.binding.classes.ContextMethodBuilder;
import org.jibx.runtime.JiBXException;
/**
* Child component (attribute or content) interface definition. This interface
* provides the basic hooks for generating code from the binding definition.
*
* @author Dennis M. Sosnoski
*/
public interface IComponent extends ILinkable
{
/**
* Check if component is an optional item.
*
* @return true if optional, false if required
*/
public boolean isOptional();
/**
* Check if component defines one or more attribute values of the
* containing element.
*
* @return true if one or more attribute values defined for
* containing element, false if not
*/
public boolean hasAttribute();
/**
* Generate code to test for attribute present. This generates code that
* tests if a child is present as determined by attributes of the containing
* start tag. It leaves the result of the test (zero if missing, nonzero if
* present) on the stack. This call is only valid if this component has one
* or more attributes for the containing element.
*
* @param mb method builder
* @throws JiBXException if configuration error
*/
public void genAttrPresentTest(ContextMethodBuilder mb)
throws JiBXException;
/**
* Generate attribute unmarshalling code. This is called within the code
* generation for the unmarshaller of the class associated with the
* containing element. It needs to generate the necessary code for handling
* the unmarshalling operation, leaving the unmarshalled object
* reference on the stack.
*
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public void genAttributeUnmarshal(ContextMethodBuilder mb)
throws JiBXException;
/**
* Generate attribute marshalling code. This is called within the code
* generation for the marshaller of the class associated with the
* containing element. It needs to generate the necessary code for handling
* the marshalling operation, consuming the marshalled object
* reference from the stack.
*
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public void genAttributeMarshal(ContextMethodBuilder mb)
throws JiBXException;
/**
* Check if component defines one or more elements or text values as
* children of the containing element. This method is only valid after the
* call to {@link #setLinkages()}.
*
* @return true if one or more content values defined
* for containing element, false if not
*/
public boolean hasContent();
/**
* Generate code to test for content present. This generates code that
* tests if a required element is present, leaving the result of the test
* (zero if missing, nonzero if present) on the stack. This call is only
* valid if this component has one or more content components for the
* containing element.
*
* @param mb method builder
* @throws JiBXException if configuration error
*/
public void genContentPresentTest(ContextMethodBuilder mb)
throws JiBXException;
/**
* Generate element or text unmarshalling code. This is called within the
* code generation for the unmarshaller of the class associated with the
* containing element. It needs to generate the necessary code for
* handling the unmarshalling operation, leaving the unmarshalled object
* reference on the stack.
*
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public void genContentUnmarshal(ContextMethodBuilder mb)
throws JiBXException;
/**
* Generate element or text marshalling code. This is called within the
* code generation for the marshaller of the class associated with the
* containing element. It needs to generate the necessary code for
* handling the marshalling operation, consuming the marshalled object
* reference from the stack.
*
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public void genContentMarshal(ContextMethodBuilder mb) throws JiBXException;
/**
* Generate code to create new instance of object. This is called within the
* code generation for the unmarshaller of the class associated with the
* containing element. It needs to generate the necessary code for creating
* an instance of the object to be unmarshalled, leaving the object
* reference on the stack.
*
* @param mb method builder
* @throws JiBXException if error in configuration
*/
public void genNewInstance(ContextMethodBuilder mb) throws JiBXException;
/**
* Get type expected by component.
*
* @return fully qualified class name of expected type
*/
public String getType();
/**
* Check if component defines an ID value for instances of context object.
*
* @return true if ID value defined for instances,
* false if not
*/
public boolean hasId();
/**
* Generate code to load ID value of instance to stack. The generated code
* should assume that the top of the stack is the reference for the
* containing object. It must consume this and leave the actual ID value
* on the stack (as a String).
*
* @param mb method builder
* @throws JiBXException if configuration error
*/
public void genLoadId(ContextMethodBuilder mb) throws JiBXException;
/**
* Get element wrapper name. If the component defines an element as the
* container for content, this returns the name information for that
* element.
*
* @return component element name, null if no wrapper element
*/
public NameDefinition getWrapperName();
// DEBUG
public void print(int depth);
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/ComponentProperty.java 0000644 0001750 0001750 00000033266 11475703134 026410 0 ustar twerner twerner /*
Copyright (c) 2003-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.jibx.binding.classes.*;
import org.jibx.binding.util.IntegerCache;
import org.jibx.runtime.JiBXException;
/**
* Property reference with binding defined by component. This handles loading
* and storing the property value, calling the wrapped component methods for
* everything else.
*
* @author Dennis M. Sosnoski
*/
public class ComponentProperty extends PassThroughComponent
{
/** Property definition. */
private final PropertyDefinition m_property;
/** Skip marshalling code tests flag. */
private boolean m_skipMarshal;
/** Fake content to force unmarshal to create an object. */
private boolean m_forceUnmarshal;
/**
* Constructor.
*
* @param prop actual property definition
* @param impl component that defines marshalling and unmarshalling
* @param skip flag for marshalling code tests to be skipped
*/
public ComponentProperty(PropertyDefinition prop, IComponent impl,
boolean skip) {
super(impl);
m_property = prop;
m_skipMarshal = skip;
}
/**
* Set flag for skipping marshalling presence test code generation.
*
* @param skip true if skipping, false if not
*/
public void setSkipping(boolean skip) {
m_skipMarshal = skip;
}
/**
* Set flag to force unmarshalling to create an object.
*
* @param force true if skipping, false if not
*/
public void setForceUnmarshal(boolean force) {
m_forceUnmarshal = force;
}
/**
* Get the property information. This is a kludge used by the ElementWrapper
* code to store a null value directly to the property when
* unmarshalling a missing or xsi:nil element.
*
* @return property information
*/
public PropertyDefinition getProperty() {
return m_property;
}
/**
* Generate the code to load, and if necessary create, the object instance
* to be unmarshalled.
*
* @param mb
* @throws JiBXException
*/
private void genLoadUnmarshalInstance(ContextMethodBuilder mb)
throws JiBXException {
// get the actual
if (m_property.isImplicit()) {
// just create a new instance for an item from a collection
mb.appendACONST_NULL();
m_component.genNewInstance(mb);
} else if (m_property.isThis()) {
// just initialize the existing instance
mb.loadObject();
m_component.genNewInstance(mb);
} else {
// create or initialize the object instance for unmarshalling
mb.loadObject();
m_property.genLoad(mb);
mb.appendCreateCast(m_property.getGetValueType(),
m_component.getType());
m_component.genNewInstance(mb);
}
}
/**
* Generate the code to store the unmarshalled object instance.
*
* @param mb
* @throws JiBXException
*/
private void genStoreUnmarshalInstance(ContextMethodBuilder mb)
throws JiBXException {
// convert the type if necessary, then store result to property
mb.appendCreateCast(m_component.getType(),
m_property.getSetValueType());
if (!m_property.isThis()) {
if (!m_property.isImplicit()) {
m_property.genStore(mb);
}
}
}
//
// IComponent interface method definitions (overrides of defaults)
public boolean isOptional() {
return m_property.isOptional();
}
public boolean hasContent() {
return m_forceUnmarshal || super.hasContent();
}
public void genAttributeUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
// load object reference for storing result if needed
boolean thisref = m_property.isThis();
if (!m_property.isImplicit() && !thisref &&
(!super.hasContent() || m_property.isLoadable())) {
mb.loadObject();
}
BranchWrapper tosave = null;
if (m_property.isOptional() && !thisref) {
// branch to unmarshal if attribute(s) present; if not present,
// set a null reference and branch to property store.
m_component.genAttrPresentTest(mb);
BranchWrapper ifpres = mb.appendIFNE(this);
mb.appendACONST_NULL();
tosave = mb.appendUnconditionalBranch(this);
mb.targetNext(ifpres);
}
// handle attribute unmarshalling
genLoadUnmarshalInstance(mb);
m_component.genAttributeUnmarshal(mb);
mb.targetNext(tosave);
// check if content also present
if (super.hasContent() && !m_property.isLoadable()) {
if (!m_property.isImplicit() && !thisref) {
// let the content unmarshalling store the instance
int slot = mb.addLocal(null,
ClassItem.typeFromName(m_component.getType()));
Integer index = IntegerCache.getInteger(slot);
mb.setKeyValue(this, index);
}
} else {
// no content present or loadable, just store directly
genStoreUnmarshalInstance(mb);
}
}
public void genAttributeMarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_skipMarshal) {
// just generate pass-through marshal code generation
mb.appendCreateCast(m_component.getType());
m_component.genAttributeMarshal(mb);
} else {
// start by generating code to load the actual object reference
if (!m_property.isImplicit()) {
mb.loadObject();
m_property.genLoad(mb);
}
BranchWrapper ifpres = null;
BranchWrapper toend = null;
if (m_property.isOptional()) {
// generate code to check nonnull for the case of an optional item,
// with branch if so; if not present, just pop the copy with branch
// to be targeted past end.
mb.appendDUP();
ifpres = mb.appendIFNONNULL(this);
mb.appendPOP();
toend = mb.appendUnconditionalBranch(this);
}
// generate code for actual marshalling if not optional, or optional and
// nonnull; then finish by setting target for optional with
// null value case
mb.targetNext(ifpres);
m_component.genAttributeMarshal(mb);
mb.targetNext(toend);
}
}
public void genContentUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
// first check that there really is content to be unmarshalled
if (!m_forceUnmarshal || super.hasContent()) {
// load object reference for storing result if needed
boolean thisref = m_property.isThis();
if (!m_property.isImplicit() && !thisref) {
mb.loadObject();
}
BranchWrapper tostore = null;
BranchWrapper toloaded = null;
if (m_property.isOptional() && !thisref) {
// see if already checked for attributes present
if (hasAttribute()) {
// attributes included, so if reference is non-null it means
// the attributes were processed and the reference can just
// be used without (re)initialization
if (!m_property.isImplicit()) {
if (m_property.isLoadable()) {
mb.loadObject();
m_property.genLoad(mb);
} else {
Integer index = (Integer)mb.getKeyValue(this);
mb.appendLoadLocal(index.intValue());
}
}
mb.appendCreateCast(m_component.getType());
mb.appendDUP();
toloaded = mb.appendIFNONNULL(this);
mb.appendPOP();
}
// now check if content present
m_component.genContentPresentTest(mb);
BranchWrapper havecont = mb.appendIFNE(this);
// force store of null reference if content not found
mb.appendACONST_NULL();
tostore = mb.appendUnconditionalBranch(this);
// load reference and initialize existing instance, or create a
// new instance if none exists
mb.targetNext(havecont);
genLoadUnmarshalInstance(mb);
} else if (hasAttribute()) {
// generate code to just load the reference, which was created
// or initialized during attribute unmarshalling
if (!m_property.isImplicit() && !thisref) {
if (m_property.isLoadable()) {
mb.loadObject();
m_property.genLoad(mb);
} else {
Integer index = (Integer)mb.getKeyValue(this);
mb.appendLoadLocal(index.intValue());
}
}
mb.appendCreateCast(m_component.getType());
} else {
// create or initialize instance to be unmarshalled
genLoadUnmarshalInstance(mb);
}
// unmarshal the content to the instance, and store it
mb.targetNext(toloaded);
m_component.genContentUnmarshal(mb);
mb.targetNext(tostore);
genStoreUnmarshalInstance(mb);
}
}
public void genContentMarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_forceUnmarshal) {
if (m_property.isImplicit()) {
// discard the object reference
mb.appendPOP();
}
} else {
if (m_skipMarshal) {
// just generate pass-through marshal code generation
mb.appendCreateCast(m_component.getType());
m_component.genContentMarshal(mb);
} else {
// start by generating code to load the actual object reference
if (!m_property.isImplicit()) {
mb.loadObject();
m_property.genLoad(mb);
}
BranchWrapper ifpres = null;
BranchWrapper tonext = null;
if (m_property.isOptional()) {
// generate code to check nonull for the case of an optional item,
// with branch if so; if not present, just pop the copy with branch
// to be targeted past end.
mb.appendDUP();
ifpres = mb.appendIFNONNULL(this);
mb.appendPOP();
tonext = mb.appendUnconditionalBranch(this);
}
// generate code for actual marshalling if not optional, or optional and
// nonnull; then finish by setting target for optional with null value
// case
mb.targetNext(ifpres);
m_component.genContentMarshal(mb);
mb.targetNext(tonext);
}
}
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.print("component " + m_property.toString());
if (m_skipMarshal) {
System.out.print(" (pass-through marshal)");
}
System.out.println();
m_component.print(depth+1);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/IContextObj.java 0000644 0001750 0001750 00000004457 11027550326 025065 0 ustar twerner twerner /*
Copyright (c) 2003-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.jibx.binding.classes.*;
/**
* Containing object context interface. This interface is implemented by binding
* definition components that link to objects and can contain nested components.
*
* @author Dennis M. Sosnoski
*/
public interface IContextObj extends ITypeBinding
{
/**
* Get class linked to binding element.
*
* @return information for class linked by binding
*/
public BoundClass getBoundClass();
/**
* Set ID property. Tells the parent binding element that a particular
* child defines an ID property for the class linked to the parent.
*
* @param child child defining the ID property
* @return true if successful, false if ID
* already defined
*/
public boolean setIdChild(IComponent child);
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/NestedCollection.java 0000644 0001750 0001750 00000104510 11072762522 026125 0 ustar twerner twerner /*
Copyright (c) 2003-2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import org.apache.bcel.generic.*;
import org.jibx.binding.classes.*;
import org.jibx.runtime.JiBXException;
/**
* Collection binding definition. This handles one or more child components,
* which may be ordered or unordered.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class NestedCollection extends NestedBase
{
//
// Method definitions used in code generation
private static final String GROWARRAY_METHOD =
"org.jibx.runtime.Utility.growArray";
private static final String GROWARRAY_SIGNATURE =
"(Ljava/lang/Object;)Ljava/lang/Object;";
private static final String RESIZEARRAY_METHOD =
"org.jibx.runtime.Utility.resizeArray";
private static final String RESIZEARRAY_SIGNATURE =
"(ILjava/lang/Object;)Ljava/lang/Object;";
private static final String CHECK_ISSTART_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.isStart";
private static final String CHECK_ISSTART_SIGNATURE = "()Z";
private static final String SKIP_ELEMENT_NAME =
"org.jibx.runtime.impl.UnmarshallingContext.skipElement";
private static final String SKIP_ELEMENT_SIGNATURE = "()V";
//
// Actual instance data.
/** Fully qualified class name of values from collection. */
private final String m_itemType;
/** Strategy for generating code to load item from collection. */
private final CollectionLoad m_loadStrategy;
/** Strategy for generating code to store item to collection. */
private final CollectionStore m_storeStrategy;
/** Optional component flag. */
private final boolean m_isOptional;
/**
* Constructor.
*
* @param parent containing binding definition context
* @param objc current object context
* @param ord ordered content flag
* @param opt optional component flag
* @param flex flexible element handling flag
* @param type fully qualified class name of values from collection (may be
* null, if child content present)
* @param load collection load code generation strategy
* @param store collection store code generation strategy
*/
public NestedCollection(IContainer parent, IContextObj objc, boolean ord,
boolean opt, boolean flex, String type, CollectionLoad load,
CollectionStore store) {
super(parent, objc, ord, flex, false);
m_itemType = type;
m_loadStrategy = load;
m_storeStrategy = store;
m_isOptional = opt;
}
/**
* Get the collection item type.
*
* @return item type
*/
public String getItemType() {
return m_itemType;
}
//
// IComponent interface method definitions
public void genNewInstance(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no instance creation");
}
public boolean hasAttribute() {
return false;
}
public void genAttrPresentTest(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no attributes present");
}
public void genAttributeUnmarshal(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no attributes present");
}
public void genAttributeMarshal(ContextMethodBuilder mb) {
throw new IllegalStateException
("Internal error - no attributes present");
}
public boolean hasContent() {
return m_contents.size() > 0;
}
public void genContentUnmarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_contents.size() > 0) {
// set up common handling and check for ordered or unordered content
m_storeStrategy.genStoreInit(mb);
BranchWrapper link = null;
int count = m_contents.size();
if (m_isOrdered) {
// just generate unmarshal code for each component in order
for (int i = 0; i < count; i++) {
// start with branch target for loop and link from last type
if (link != null) {
mb.initStackState(link);
}
BranchTarget start = mb.appendTargetNOP();
if (link != null) {
link.setTarget(start, mb);
}
// generate code to check if an element matching this
// component type is present
IComponent child = (IComponent)m_contents.get(i);
child.genContentPresentTest(mb);
link = mb.appendIFEQ(this);
// follow with code to unmarshal the component and store to
// collection, ending with loop back to start of this
// component
child.genContentUnmarshal(mb);
if (m_itemType != null && !ClassItem.isPrimitive(m_itemType)) {
mb.appendCreateCast(m_itemType);
}
m_storeStrategy.genStoreItem(mb);
mb.appendUnconditionalBranch(this).setTarget(start, mb);
}
} else {
// generate unmarshal loop code that checks for each component,
// branching to the next component until one is found and
// exiting the loop only when no component is matched
BranchTarget first = mb.appendTargetNOP();
for (int i = 0; i < count; i++) {
if (link != null) {
mb.targetNext(link);
}
IComponent child = (IComponent)m_contents.get(i);
child.genContentPresentTest(mb);
link = mb.appendIFEQ(this);
child.genContentUnmarshal(mb);
if (m_itemType != null && !ClassItem.isPrimitive(m_itemType)) {
mb.appendCreateCast(m_itemType);
}
m_storeStrategy.genStoreItem(mb);
mb.appendUnconditionalBranch(this).setTarget(first, mb);
}
// handle fall through condition depending on flexible flag
if (m_isFlexible) {
// exit loop if not positioned at element start
mb.targetNext(link);
mb.loadContext();
mb.appendCallVirtual(CHECK_ISSTART_NAME,
CHECK_ISSTART_SIGNATURE);
link = mb.appendIFEQ(this);
// ignore unknown element and loop back to start
mb.loadContext();
mb.appendCallVirtual(SKIP_ELEMENT_NAME,
SKIP_ELEMENT_SIGNATURE);
mb.appendUnconditionalBranch(this).setTarget(first, mb);
}
}
// patch final test failure branch to fall through loop
mb.targetNext(link);
m_storeStrategy.genStoreDone(mb);
} else {
throw new IllegalStateException
("Internal error - no content present");
}
}
public void genContentMarshal(ContextMethodBuilder mb)
throws JiBXException {
if (m_contents.size() > 0) {
// set up common handling of unknown item and collection empty
BranchWrapper[] ifempties;
BranchWrapper link = null;
m_loadStrategy.genLoadInit(mb);
// check for ordered or unordered content
int count = m_contents.size();
if (m_isOrdered) {
// generate marshal code for each component type in order, with
// an exception generated if the end of the possible component
// list is reached with anything left in the collection
ifempties = new BranchWrapper[count];
for (int i = 0; i < count; i++) {
// start generated code with loading next value from
// collection
if (link != null) {
mb.initStackState(link, 1);
}
BranchTarget start = mb.appendTargetNOP();
ifempties[i] = m_loadStrategy.genLoadItem(mb);
mb.targetNext(link);
// if multiple types are included in content, append code to
// check if item type matches this component
IComponent child = (IComponent)m_contents.get(i);
String type = child.getType();
if (count > 1) {
mb.appendDUP();
mb.appendInstanceOf(type);
link = mb.appendIFEQ(this);
}
if ((!"java.lang.Object".equals(type) &&
!ClassItem.isPrimitive(type))) {
mb.appendCreateCast(type);
}
// finish with code to marshal the component, looping back
// to start of block for more of same type
child.genContentMarshal(mb);
mb.appendUnconditionalBranch(this).setTarget(start, mb);
}
} else {
// generate marshal loop code that loads an item from the
// collection and then checks to see if it matches a component
// type, branching to the next component until a match is found
// (or generating an exception on no match)
BranchTarget start = mb.appendTargetNOP();
ifempties = new BranchWrapper[1];
ifempties[0] = m_loadStrategy.genLoadItem(mb);
for (int i = 0; i < count; i++) {
// start by setting target for branch from last component
mb.targetNext(link);
// if multiple types are included in content, append code to
// check if item type matches this component
IComponent child = (IComponent)m_contents.get(i);
String type = child.getType();
if (count > 1 || (!"java.lang.Object".equals(type) &&
!ClassItem.isPrimitive(type))) {
mb.appendDUP();
mb.appendInstanceOf(type);
link = mb.appendIFEQ(this);
mb.appendCreateCast(type);
}
// finish with code to marshal the component, branching back
// to start of loop
child.genContentMarshal(mb);
mb.appendUnconditionalBranch(this).setTarget(start, mb);
}
}
// patch final test failure branch to generate an exception
if (link != null) {
// instruction sequence for exception is create new exception
// object, build message in StringBuffer using type of item
// from stack, convert StringBuffer to String, invoke the
// exeception constructor with the String, and finally throw
// the exception
mb.targetNext(link);
mb.appendCreateNew("java.lang.StringBuffer");
mb.appendDUP();
mb.appendLoadConstant("Collection item of type ");
mb.appendCallInit("java.lang.StringBuffer",
"(Ljava/lang/String;)V");
mb.appendSWAP();
mb.appendDUP();
BranchWrapper ifnull = mb.appendIFNULL(this);
mb.appendCallVirtual("java.lang.Object.getClass",
"()Ljava/lang/Class;");
mb.appendCallVirtual("java.lang.Class.getName",
"()Ljava/lang/String;");
BranchWrapper toend = mb.appendUnconditionalBranch(this);
mb.targetNext(ifnull);
mb.appendPOP();
mb.appendLoadConstant("NULL");
mb.targetNext(toend);
mb.appendCallVirtual("java.lang.StringBuffer.append",
"(Ljava/lang/String;)Ljava/lang/StringBuffer;");
mb.appendLoadConstant(" has no binding defined");
mb.appendCallVirtual("java.lang.StringBuffer.append",
"(Ljava/lang/String;)Ljava/lang/StringBuffer;");
mb.appendCallVirtual("java.lang.StringBuffer.toString",
"()Ljava/lang/String;");
mb.appendCreateNew(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
mb.appendDUP_X1();
mb.appendSWAP();
mb.appendCallInit(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS,
MethodBuilder.EXCEPTION_CONSTRUCTOR_SIGNATURE1);
mb.appendThrow();
}
// finish by setting target for collection empty case(s)
m_loadStrategy.genLoadDone(mb);
mb.targetNext(ifempties);
} else {
throw new IllegalStateException
("Internal error - no content present");
}
}
public boolean hasId() {
return false;
}
public void genLoadId(ContextMethodBuilder mb) throws JiBXException {
throw new IllegalStateException("No ID child");
}
public NameDefinition getWrapperName() {
return null;
}
public boolean isOptional() {
return m_isOptional;
}
public void setLinkages() throws JiBXException {
for (int i = 0; i < m_contents.size(); i++) {
((IComponent)m_contents.get(i)).setLinkages();
}
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.print("collection " +
(m_isOrdered ? "ordered" : "unordered"));
if (m_itemType != null) {
System.out.print(" (" + m_itemType + ")");
}
if (isFlexible()) {
System.out.print(", flexible");
}
System.out.println();
for (int i = 0; i < m_contents.size(); i++) {
IComponent comp = (IComponent)m_contents.get(i);
comp.print(depth+1);
}
}
/**
* Base class for collection item load strategy. The implementation class
* must handle the appropriate form of code generation for the type of
* collection being used.
*/
/*package*/ static abstract class CollectionBase
{
/** Double word value flag. */
private final boolean m_isDoubleWord;
/**
* Constructor.
*
* @param doubword double word value flag
*/
protected CollectionBase(boolean doubword) {
m_isDoubleWord = doubword;
}
/**
* Append the appropriate instruction to swap the top of the stack
* (which must be a single-word value) with an item value (which may
* be one or two words, as configured for this collection).
*
* @param mb method
*/
protected void appendSWAP(MethodBuilder mb) {
if (m_isDoubleWord) {
mb.appendSWAP1For2();
} else {
mb.appendSWAP();
}
}
/**
* Append the appropriate instruction to pop the item value (which may
* be one or two words, as configured for this collection) from the top
* of the stack.
*
* @param mb method
*/
protected void appendPOP(MethodBuilder mb) {
if (m_isDoubleWord) {
mb.appendPOP2();
} else {
mb.appendPOP();
}
}
}
/**
* Base class for collection item load strategy. The implementation class
* must handle the appropriate form of code generation for the type of
* collection being used.
*/
/*package*/ static abstract class CollectionLoad extends CollectionBase
{
/**
* Constructor.
*
* @param doubword double word value flag
*/
protected CollectionLoad(boolean doubword) {
super(doubword);
}
/**
* Generate code to initialize collection for loading items. This
* generates the necessary code for handling the initialization. It
* must be called before attempting to call the {@link #genLoadItem}
* method. The base class implementation does nothing.
*
* @param mb method builder
* @throws JiBXException if error in configuration
*/
protected void genLoadInit(ContextMethodBuilder mb)
throws JiBXException {}
/**
* Generate code to load next item from collection. This generates the
* necessary code for handling the load operation, leaving the item on
* the stack. The {@link #genLoadInit} method must be called before
* calling this method, and the {@link #genLoadDone} method must be
* called after the last call to this method. This method must be
* overridden by each subclass.
*
* @param mb method builder
* @return branch wrapper for case of done with collection
* @throws JiBXException if error in configuration
*/
protected abstract BranchWrapper genLoadItem(ContextMethodBuilder mb)
throws JiBXException;
/**
* Generate code to clean up after loading items from collection. This
* generates the necessary code for handling the clean up. It must be
* called after the last call to {@link #genLoadItem}. The base class
* implementation does nothing.
*
* @param mb method builder
* @throws JiBXException if error in configuration
*/
protected void genLoadDone(ContextMethodBuilder mb)
throws JiBXException {}
}
/**
* Base class for collection item store strategy. The implementation class
* must handle the appropriate form of code generation for the type of
* collection being used.
*/
/*package*/ static abstract class CollectionStore extends CollectionBase
{
/**
* Constructor.
*
* @param doubword double word value flag
*/
protected CollectionStore(boolean doubword) {
super(doubword);
}
/**
* Generate code to initialize collection for storing items. This
* generates the necessary code for handling the initialization,
* including creating the collection object if appropriate. It must be
* called before attempting to call the {@link #genStoreItem} method.
* The base class implementation does nothing.
*
* @param mb method builder
* @throws JiBXException if error in configuration
*/
protected void genStoreInit(ContextMethodBuilder mb)
throws JiBXException {}
/**
* Generate code to store next item to collection. This generates the
* necessary code for handling the store operation, removing the item
* from the stack. The {@link #genStoreInit} method must be called
* before calling this method, and the {@link #genStoreDone} method must
* be called after the last call to this method. This method must be
* overridden by each subclass.
*
* @param mb method builder
* @throws JiBXException if error in configuration
*/
protected abstract void genStoreItem(ContextMethodBuilder mb)
throws JiBXException;
/**
* Generate code to clean up after storing items to collection. This
* generates the necessary code for handling the clean up. It must be
* called after the last call to {@link #genStoreItem}. The base class
* implementation does nothing.
*
* @param mb method builder
* @throws JiBXException if error in configuration
*/
protected void genStoreDone(ContextMethodBuilder mb)
throws JiBXException {}
}
/**
* Collection item load strategy for collection with items accessed by
* index number.
*/
/*package*/ static class IndexedLoad extends CollectionLoad
{
/** Method used to get count of items in collection. */
private final ClassItem m_sizeMethod;
/** Method used to get items by index from collection. */
private final ClassItem m_getMethod;
/**
* Constructor.
*
* @param size method used to get count of items in collection
* @param doubword double word value flag
* @param get method used to retrieve items by index from collection
*/
/*package*/ IndexedLoad(ClassItem size, boolean doubword,
ClassItem get) {
super(doubword);
m_sizeMethod = size;
m_getMethod = get;
}
protected void genLoadInit(ContextMethodBuilder mb)
throws JiBXException {
// create index local with appended code to set initial value
mb.appendLoadConstant(-1);
mb.defineSlot(m_getMethod, Type.INT);
// create size local with appended code to set initial value from
// collection method call
if (!m_sizeMethod.isStatic()) {
mb.loadObject();
}
mb.appendCall(m_sizeMethod);
mb.defineSlot(m_sizeMethod, Type.INT);
}
protected BranchWrapper genLoadItem(ContextMethodBuilder mb)
throws JiBXException {
// start by getting local variable slots for the index and size
int islot = mb.getSlot(m_getMethod);
int sslot = mb.getSlot(m_sizeMethod);
// append code to first increment index, then check for end of
// collection reached
mb.appendIncrementLocal(1, islot);
mb.appendLoadLocal(islot);
mb.appendLoadLocal(sslot);
mb.appendISUB();
BranchWrapper ifempty = mb.appendIFGE(this);
// finish by calling collection method to load item at current index
// position
if (!m_getMethod.isStatic()) {
mb.loadObject();
}
mb.appendLoadLocal(islot);
mb.appendCall(m_getMethod);
return ifempty;
}
protected void genLoadDone(ContextMethodBuilder mb)
throws JiBXException {
mb.freeSlot(m_getMethod);
mb.freeSlot(m_sizeMethod);
}
}
/**
* Collection item store strategy for collection with items set by
* index number.
*/
/*package*/ static class IndexedStore extends CollectionStore
{
/** Method used to set items by index in collection. */
private final ClassItem m_setMethod;
/** Flag for method returns result. */
private final boolean m_isReturned;
/**
* Constructor.
*
* @param set method used to store items by index in collection
* @param doubword double word value flag
* @param ret value returned by add flag
*/
/*package*/ IndexedStore(ClassItem set, boolean doubword, boolean ret) {
super(doubword);
m_setMethod = set;
m_isReturned = ret;
}
protected void genStoreInit(ContextMethodBuilder mb)
throws JiBXException {
// create index local with appended code to set initial value
mb.appendLoadConstant(-1);
mb.defineSlot(m_setMethod, Type.INT);
}
protected void genStoreItem(ContextMethodBuilder mb)
throws JiBXException {
// start by getting local variable slot for the index
int islot = mb.getSlot(m_setMethod);
// append code to first load object and swap with item, then
// increment index and swap copy with item, and finally call
// collection method to store item at new index position
if (!m_setMethod.isStatic()) {
mb.loadObject();
appendSWAP(mb);
}
mb.appendIncrementLocal(1, islot);
mb.appendLoadLocal(islot);
appendSWAP(mb);
mb.appendCall(m_setMethod);
if (m_isReturned) {
appendPOP(mb);
}
}
protected void genStoreDone(ContextMethodBuilder mb)
throws JiBXException {
mb.freeSlot(m_setMethod);
}
}
/**
* Collection item load strategy for collection with items accessed by
* iterator or enumeration.
*/
/*package*/ static class IteratorLoad extends CollectionLoad
{
/** Method used to get iterator for collection. */
private final ClassItem m_iterMethod;
/** Fully qualified method name to test if more in iteration. */
private final String m_moreName;
/** Fully qualified method name to get next item in iteration. */
private final String m_nextName;
/**
* Constructor.
*
* @param iter method to get iterator or enumerator from collection
* @param doubword double word value flag
* @param more fully qualified method name to test if more in iteration
* @param next fully qualified method name to get next item in iteration
*/
/*package*/ IteratorLoad(ClassItem iter, boolean doubword, String more,
String next) {
super(doubword);
m_iterMethod = iter;
m_moreName = more;
m_nextName = next;
}
protected void genLoadInit(ContextMethodBuilder mb)
throws JiBXException {
// create iterator local with appended code to set initial value
if (!m_iterMethod.isStatic()) {
mb.loadObject();
}
mb.appendCall(m_iterMethod);
mb.defineSlot(m_iterMethod, Type.getType("Ljava/util/Iterator;"));
}
protected BranchWrapper genLoadItem(ContextMethodBuilder mb)
throws JiBXException {
// start with code to load and test iterator
int islot = mb.getSlot(m_iterMethod);
mb.appendLoadLocal(islot);
mb.appendCallInterface(m_moreName, "()Z");
BranchWrapper ifempty = mb.appendIFEQ(this);
// append code to get next item from iterator
mb.appendLoadLocal(islot);
mb.appendCallInterface(m_nextName, "()Ljava/lang/Object;");
return ifempty;
}
protected void genLoadDone(ContextMethodBuilder mb)
throws JiBXException {
mb.freeSlot(m_iterMethod);
}
}
/**
* Collection item store strategy for collection with add method.
*/
/*package*/ static class AddStore extends CollectionStore
{
/** Method used to add item to collection. */
private final ClassItem m_addMethod;
/** Flag for method returns result. */
private final boolean m_isReturned;
/**
* Constructor.
*
* @param add method used to add item to collection
* @param doubword double word value flag
* @param ret value returned by add flag
*/
/*package*/ AddStore(ClassItem add, boolean doubword, boolean ret) {
super(doubword);
m_addMethod = add;
m_isReturned = ret;
}
protected void genStoreItem(ContextMethodBuilder mb)
throws JiBXException {
// append code to call collection method to add the item
if (!m_addMethod.isStatic()) {
mb.loadObject();
appendSWAP(mb);
}
mb.appendCall(m_addMethod);
if (m_isReturned) {
appendPOP(mb);
}
}
}
/**
* Collection item load strategy for array.
*/
/*package*/ static class ArrayLoad extends CollectionLoad
{
/** Array item type. */
private final String m_itemType;
/** Handle for referencing loop counter local variable. */
private Object m_slotHandle = new Object();
/**
* Constructor.
*
* @param itype array item type
* @param doubword double word value flag
*/
/*package*/ ArrayLoad(String itype, boolean doubword) {
super(doubword);
m_itemType = itype;
}
protected void genLoadInit(ContextMethodBuilder mb)
throws JiBXException {
// create index local with initial value -1
mb.appendLoadConstant(-1);
mb.defineSlot(m_slotHandle, Type.INT);
}
protected BranchWrapper genLoadItem(ContextMethodBuilder mb)
throws JiBXException {
// start by getting local variable slots for the index
int islot = mb.getSlot(m_slotHandle);
// append code to first increment index, then check for end of
// collection reached
mb.appendIncrementLocal(1, islot);
mb.appendLoadLocal(islot);
mb.loadObject();
mb.appendARRAYLENGTH();
mb.appendISUB();
BranchWrapper ifempty = mb.appendIFGE(this);
// finish by loading array item at current index position
mb.loadObject();
mb.appendLoadLocal(islot);
mb.appendALOAD(m_itemType);
return ifempty;
}
protected void genLoadDone(ContextMethodBuilder mb)
throws JiBXException {
mb.freeSlot(m_slotHandle);
}
}
/**
* Collection item store strategy for array.
*/
/*package*/ static class ArrayStore extends CollectionStore
{
/** Array item type. */
private final String m_itemType;
/**
* Constructor.
*
* @param itype array item type
* @param doubword double word value flag
*/
/*package*/ ArrayStore(String itype, boolean doubword) {
super(doubword);
m_itemType = itype;
}
protected void genStoreInit(ContextMethodBuilder mb)
throws JiBXException {
// create index local with initial value -1
mb.appendLoadConstant(-1);
mb.defineSlot(m_itemType, Type.INT);
}
protected void genStoreItem(ContextMethodBuilder mb)
throws JiBXException {
// start by getting local variable slot for the index
int islot = mb.getSlot(m_itemType);
// append code to first increment index and check array size
mb.appendIncrementLocal(1, islot);
mb.appendLoadLocal(islot);
mb.loadObject();
mb.appendARRAYLENGTH();
mb.appendISUB();
BranchWrapper ifnotfull = mb.appendIFLT(this);
// grow the array size to make room for more values
mb.loadObject();
mb.appendCallStatic(GROWARRAY_METHOD, GROWARRAY_SIGNATURE);
mb.storeObject();
// swap the array reference with the item, swap index with item, and
// finally store item at new index position
mb.targetNext(ifnotfull);
mb.loadObject();
appendSWAP(mb);
mb.appendLoadLocal(islot);
appendSWAP(mb);
if (!ClassItem.isPrimitive(m_itemType)) {
mb.appendCreateCast(m_itemType);
}
mb.appendASTORE(m_itemType);
}
protected void genStoreDone(ContextMethodBuilder mb)
throws JiBXException {
// resize the array to match actual item count
int islot = mb.getSlot(m_itemType);
mb.appendIncrementLocal(1, islot);
mb.appendLoadLocal(islot);
mb.loadObject();
mb.appendCallStatic(RESIZEARRAY_METHOD, RESIZEARRAY_SIGNATURE);
mb.storeObject();
mb.freeSlot(m_itemType);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/def/MappingDefinition.java 0000644 0001750 0001750 00000107621 11202365544 026277 0 ustar twerner twerner /*
Copyright (c) 2003-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.def;
import java.util.ArrayList;
import org.apache.bcel.Constants;
import org.apache.bcel.generic.Type;
import org.jibx.binding.classes.BoundClass;
import org.jibx.binding.classes.BranchTarget;
import org.jibx.binding.classes.BranchWrapper;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.ClassItem;
import org.jibx.binding.classes.ContextMethodBuilder;
import org.jibx.binding.classes.ExceptionMethodBuilder;
import org.jibx.binding.classes.MethodBuilder;
import org.jibx.binding.classes.MungedClass;
import org.jibx.runtime.JiBXException;
/**
* Normal mapping with defined binding. This is used for a mapping definition
* which includes detailed binding information (rather than marshaller and
* unmarshaller classes which handle the binding directly).
*
* @author Dennis M. Sosnoski
*/
public class MappingDefinition extends MappingBase
{
//
// Constants and such related to code generation.
// definitions used in generating the adapter class
private static final String ADAPTERCLASS_SUFFIX = "_access";
private static final String MARSHAL_METHODNAME = "marshal";
private static final String BASEMARSHAL_METHODNAME = "baseMarshal";
private static final String UNMARSHAL_METHODNAME = "unmarshal";
private static final String ISPRESENT_METHODNAME = "isPresent";
private static final String UNMARSHALCONTEXT_CLASS =
"org.jibx.runtime.impl.UnmarshallingContext";
private static final String MARSHALCONTEXT_CLASS =
"org.jibx.runtime.impl.MarshallingContext";
private static final String UNMARSHAL_ISATMETHOD =
"org.jibx.runtime.IUnmarshallingContext.isAt";
private static final String UNMARSHAL_ISATSIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;)Z";
private static final String GETINDEX_METHOD =
"org.jibx.runtime.IMarshallable.JiBX_getIndex";
private static final String UNMARSHALLERPRESENT_METHOD =
"org.jibx.runtime.IUnmarshaller.isPresent";
private static final String UNMARSHALLERPRESENT_SIGNATURE =
"(Lorg/jibx/runtime/IUnmarshallingContext;)Z";
private static final String UNMARSHALCONTEXT_INTERFACE =
"org.jibx.runtime.IUnmarshallingContext";
private static final String MARSHALCONTEXT_INTERFACE =
"org.jibx.runtime.IMarshallingContext";
private static final String CURRENTELEMENT_METHOD =
"org.jibx.runtime.impl.UnmarshallingContext.currentNameString";
private static final String CURRENTELEMENT_SIGNATURE =
"()Ljava/lang/String;";
private static final String PARSERNEXT_METHOD =
"org.jibx.runtime.impl.UnmarshallingContext.next";
private static final String PARSERNEXT_SIGNATURE = "()I";
private static final String CLOSESTART_METHOD =
"org.jibx.runtime.impl.MarshallingContext.closeStartContent";
private static final String CLOSESTART_SIGNATURE =
"()Lorg/jibx/runtime/impl/MarshallingContext;";
private static final String ADDUNMARSHALLER_METHOD =
"org.jibx.runtime.impl.UnmarshallingContext.addUnmarshalling";
private static final String ADDUNMARSHALLER_SIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V";
private static final String REMOVEUNMARSHALLER_METHOD =
"org.jibx.runtime.impl.UnmarshallingContext.removeUnmarshalling";
private static final String REMOVEUNMARSHALLER_SIGNATURE =
"(Ljava/lang/String;)V";
private static final String ADDMARSHALLER_METHOD =
"org.jibx.runtime.impl.MarshallingContext.addMarshalling";
private static final String ADDMARSHALLER_SIGNATURE =
"(Ljava/lang/String;Ljava/lang/String;)V";
private static final String REMOVEMARSHALLER_METHOD =
"org.jibx.runtime.impl.MarshallingContext.removeMarshalling";
private static final String REMOVEMARSHALLER_SIGNATURE =
"(Ljava/lang/String;)V";
private static final String PUSH_NAMESPACES_METHOD =
"org.jibx.runtime.IMarshallingContext.pushNamespaces";
private static final String PUSH_NAMESPACES_SIG =
"(Ljava/lang/String;)V";
private static final String POP_NAMESPACES_METHOD =
"org.jibx.runtime.IMarshallingContext.popNamespaces";
private static final String POP_NAMESPACES_SIG = "()V";
private static final String EQUALS_METHODNAME = "java.lang.String.equals";
private static final String EQUALS_SIGNATURE = "(Ljava/lang/Object;)Z";
// argument list for the unmarshaller methods
private static final Type[] ISPRESENT_METHOD_ARGS =
{
ClassItem.typeFromName("org.jibx.runtime.IUnmarshallingContext")
};
private static final Type[] UNMARSHAL_METHOD_ARGS =
{
Type.OBJECT,
ClassItem.typeFromName("org.jibx.runtime.IUnmarshallingContext")
};
// argument list for the marshaller methods
private static final Type[] MARSHAL_METHOD_ARGS =
{
Type.OBJECT,
ClassItem.typeFromName("org.jibx.runtime.IMarshallingContext")
};
//
// Data shared with other classes within package
// interface list for adapter with unmarshaller only
/*package*/ static final String[] UNMARSHALLER_INTERFACES =
{
UNMARSHALLER_INTERFACE
};
// interface list for adapter with marshaller only
/*package*/ static final String[] MARSHALLER_INTERFACES =
{
MARSHALLER_INTERFACE
};
// interface list for adapter with both unmarshaller and marshaller
/*package*/ static final String[] BOTH_INTERFACES =
{
UNMARSHALLER_INTERFACE, MARSHALLER_INTERFACE
};
//
// Actual instance data.
/** Containing binding definition structure. */
private final IContainer m_container;
/** Definition context for mapping. */
private final DefinitionContext m_defContext;
/** Class linked to mapping. */
private final BoundClass m_class;
/** Mapped element name (may be null if abstract mapping). */
private final NameDefinition m_name;
/** Abstract mapping flag. */
private final boolean m_isAbstract;
/** Name of abstract base type. */
private final String m_baseType;
/** Binding structure defining the mapping. */
private final ObjectBinding m_binding;
/** Abstract binding this one is based on (null if not an
extension). */
private IMapping m_baseMapping;
/** Constructed marshaller class. */
private ClassFile m_marshaller;
/** Constructed unmarshaller class. */
private ClassFile m_unmarshaller;
/** Mappings which extend this one (null if none). */
private ArrayList m_extensions;
/** Reference type of mapping, as fully qualified class name. */
private String m_referenceType;
/**
* Constructor.
*
* @param contain containing binding definition structure
* @param defc definition context for this mapping
* @param type bound class name
* @param name mapped element name information (null if none)
* @param tname qualified type name for abstract mapping (null
* if none)
* @param abs abstract mapping flag
* @param base abstract mapping extended by this one
* @param bind binding definition component (may be null if a
* concrete mapping)
* @param nillable flag for nillable element
* @throws JiBXException if class definition not found
*/
public MappingDefinition(IContainer contain, DefinitionContext defc,
String type, NameDefinition name, String tname, boolean abs,
String base, ObjectBinding bind, boolean nillable) throws JiBXException {
super(contain, type, tname);
m_binding = bind;
if (name == null) {
setWrappedComponent(bind);
} else {
setWrappedComponent(new ElementWrapper(defc, name, bind, nillable));
}
m_container = contain;
m_defContext = defc;
m_class = BoundClass.getInstance(type, null);
m_referenceType = type == null ? "java.lang.Object" : type;
m_name = name;
m_isAbstract = abs;
m_baseType = base;
}
/**
* Check if one or more namespaces are defined for element.
*
* @return true if namespaces are defined, false
* if not
*/
/*package*/ boolean hasNamespace() {
return m_defContext.hasNamespace();
}
/**
* Generate code for loading namespace index and URI arrays.
*
* @param mb method builder for generated code
*/
/*package*/ void genLoadNamespaces(MethodBuilder mb) {
m_defContext.genLoadNamespaces(mb);
}
/**
* Get the mapped class information. This implements the method used by the
* base class.
*
* @return information for mapped class
*/
public BoundClass getBoundClass() {
return m_class;
}
/**
* Links extension mappings to their base mappings. This must be done before
* the more general linking step in order to determine which abstract
* mappings are standalone and which are extended by other mappings
*
* @throws JiBXException if error in linking
*/
public void linkMappings() throws JiBXException {
if (m_baseType != null) {
m_baseMapping = m_defContext.getClassMapping(m_baseType);
if (m_baseMapping == null) {
throw new JiBXException("Mapping for base class " + m_baseType +
" not defined");
}
m_baseMapping.addExtension(this);
}
m_defContext.linkMappings();
}
//
// IMapping interface method definitions
public String getBoundType() {
return m_class.getClassName();
}
public String getReferenceType() {
return m_referenceType;
}
public IComponent getImplComponent() {
return m_component;
}
public ClassFile getMarshaller() {
return m_marshaller;
}
public ClassFile getUnmarshaller() {
return m_unmarshaller;
}
public NameDefinition getName() {
return m_name;
}
public void addNamespace(NamespaceDefinition ns) throws JiBXException {
m_defContext.addNamespace(ns);
}
public boolean isAbstract() {
return m_isAbstract;
}
public boolean isBase() {
return m_extensions != null && m_extensions.size() > 0;
}
public void addExtension(MappingDefinition mdef) throws JiBXException {
if (m_extensions == null) {
m_extensions = new ArrayList();
}
if (!m_extensions.contains(mdef)) {
m_extensions.add(mdef);
}
ClassFile cf = mdef.getBoundClass().getClassFile();
if (!cf.isSuperclass(m_referenceType) &&
!cf.isImplements(m_referenceType)) {
m_referenceType = "java.lang.Object";
}
}
public IComponent buildRef(IContainer parent, IContextObj objc, String type,
PropertyDefinition prop) throws JiBXException {
if (prop.isThis()) {
// directly incorporate base mapping definition
return new BaseMappingWrapper(m_component);
} else if (m_isAbstract && m_extensions == null) {
// create reference to use mapping definition directly
ComponentProperty comp =
new ComponentProperty(prop, m_component, false);
if (!hasAttribute() && !hasContent()) {
comp.setForceUnmarshal(true);
}
return comp;
} else {
// create link to mapping definition
DirectObject dobj = new DirectObject(m_container, null,
m_class.getClassFile(), m_isAbstract || m_extensions != null,
m_marshaller, m_unmarshaller, getMappingName(), null, null);
return new DirectProperty(prop, dobj);
}
}
public ArrayList getNamespaces() {
return m_defContext.getNamespaces();
}
/**
* Add abstract marshaller interface to handler class. This adds the
* interface and generates the {@link
* org.jibx.runtime.IAbstractMarshaller#baseMarshal(Object,
* org.jibx.runtime.IMarshallingContext)} method responsible for passing
* handling on to the appropriate extension class.
*
* @param cf handler class
*/
private void generateAbstractMarshaller(ClassFile cf) {
// build the implementation method
ContextMethodBuilder mb = new ContextMethodBuilder(BASEMARSHAL_METHODNAME,
Type.VOID, MARSHAL_METHOD_ARGS, cf,
Constants.ACC_PUBLIC|Constants.ACC_FINAL,
1, "java.lang.Object", 2, MARSHALCONTEXT_INTERFACE);
mb.addException(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
// TODO: optionally check for null value on object
mb.loadContext();
mb.loadObject();
mb.appendCallVirtual("java.lang.Object.getClass",
"()Ljava/lang/Class;");
mb.appendCallVirtual("java.lang.Class.getName", "()Ljava/lang/String;");
mb.appendCallInterface(GETMARSHALLER_METHOD, GETMARSHALLER_SIGNATURE);
mb.appendDUP();
mb.appendLoadConstant(getMappingName());
mb.appendCallInterface(CHECKEXTENDS_FULLNAME, CHECKEXTENDS_SIGNATURE);
BranchWrapper ifvalid = mb.appendIFNE(this);
// generate and throw exception describing the problem
mb.appendCreateNew("java.lang.StringBuffer");
mb.appendDUP();
mb.appendLoadConstant("Mapping for type ");
mb.appendCallInit("java.lang.StringBuffer", "(Ljava/lang/String;)V");
mb.appendDUP();
mb.loadObject();
mb.appendCallVirtual("java.lang.Object.getClass",
"()Ljava/lang/Class;");
mb.appendCallVirtual("java.lang.Class.getName", "()Ljava/lang/String;");
mb.appendCallVirtual("java.lang.StringBuffer.append",
"(Ljava/lang/String;)Ljava/lang/StringBuffer;");
mb.appendDUP();
mb.appendLoadConstant(" must extend abstract mapping for " +
"type " + m_class.getClassName());
mb.appendCallVirtual("java.lang.StringBuffer.append",
"(Ljava/lang/String;)Ljava/lang/StringBuffer;");
mb.appendCallVirtual("java.lang.StringBuffer.toString",
"()Ljava/lang/String;");
mb.appendCreateNew(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
mb.appendDUP_X1();
mb.appendSWAP();
mb.appendCallInit(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS,
MethodBuilder.EXCEPTION_CONSTRUCTOR_SIGNATURE1);
mb.appendThrow();
// for valid extension mapping, just call the marshaller
mb.targetNext(ifvalid);
mb.loadObject();
mb.loadContext();
mb.appendCallInterface(MARSHALLERMARSHAL_METHOD,
MARSHALLERMARSHAL_SIGNATURE);
mb.appendReturn();
mb.codeComplete(false);
mb.addMethod();
// add extended interface to constructed class
cf.addInterface(ABSTRACTMARSHALLER_INTERFACE);
}
/**
* Generate the {@link org.jibx.runtime.IMarshaller#isExtension(String)}
* method to check if this mapping is extending a particular abstract
* mapping.
*
* @param cf
* @param hasname
*/
private void generateIfExtendingCheck(ClassFile cf, boolean hasname) {
// build the method
ExceptionMethodBuilder xb = new ExceptionMethodBuilder
(CHECKEXTENDS_METHODNAME, CHECKEXTENDS_SIGNATURE, cf,
Constants.ACC_PUBLIC|Constants.ACC_FINAL);
xb.appendLoadLocal(1);
xb.appendLoadConstant(getMappingName());
xb.appendCallVirtual(EQUALS_METHODNAME, EQUALS_SIGNATURE);
ArrayList ifmatches = new ArrayList();
ifmatches.add(xb.appendIFNE(this));
IMapping base = m_baseMapping;
while (base != null) {
xb.appendLoadLocal(1);
xb.appendLoadConstant(base.getMappingName());
xb.appendCallVirtual(EQUALS_METHODNAME, EQUALS_SIGNATURE);
ifmatches.add(xb.appendIFNE(this));
if (base instanceof MappingDefinition) {
base = ((MappingDefinition)base).m_baseMapping;
} else {
break;
}
}
xb.appendICONST_0();
xb.appendReturn("int");
for (int i = 0; i < ifmatches.size(); i++) {
xb.targetNext((BranchWrapper)ifmatches.get(i));
}
xb.appendICONST_1();
xb.appendReturn("int");
xb.codeComplete(false);
xb.addMethod();
}
/**
* Generate the {@link org.jibx.runtime.IUnmarshaller#unmarshal(Object,
* org.jibx.runtime.IUnmarshallingContext)} method implementation.
*
* @param cf class to receive method
* @param hasattr attribute definition present flag
* @param hascont content definition present flag
* @param hasname element name defined by this mapping flag
* @throws JiBXException
*/
private void generateUnmarshalImplementation(ClassFile cf, boolean hasattr,
boolean hascont, boolean hasname) throws JiBXException {
// build the unmarshal method for item; this just generates code
// to unmarshal attributes and content, first creating an
// instance of the class if one was not passed in, then
// returning the unmarshalled instance as the value of the call
String type = m_class.getClassName();
ContextMethodBuilder mb = new ContextMethodBuilder(UNMARSHAL_METHODNAME,
Type.OBJECT, UNMARSHAL_METHOD_ARGS, cf,
Constants.ACC_PUBLIC|Constants.ACC_FINAL, 1, type,
2, UNMARSHALCONTEXT_INTERFACE);
mb.addException(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
// first part of generated code just checks if an object has
// been supplied; if it has, this can just go direct to
// unmarshalling
mb.loadObject();
BranchWrapper ifnnull = mb.appendIFNONNULL(this);
// check for extension mapping handling required
if (m_extensions != null) {
// generate name comparison unless an abstract mapping
BranchWrapper ifthis = null;
if (hasname) {
// test if at defined element name
mb.addException(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
mb.loadContext();
m_name.genPushUriPair(mb);
mb.appendCallInterface(UNMARSHAL_ISATMETHOD,
UNMARSHAL_ISATSIGNATURE);
ifthis = mb.appendIFNE(this);
}
// build code to check each extension mapping in turn,
// keeping an instance of the unmarshaller for the matching
// extension
BranchWrapper[] iffounds =
new BranchWrapper[m_extensions.size()];
for (int i = 0; i < iffounds.length; i++) {
IMapping map = (IMapping)m_extensions.get(i);
mb.loadContext();
mb.appendLoadConstant(map.getMappingName());
mb.appendCallInterface(GETUNMARSHALLER_METHOD,
GETUNMARSHALLER_SIGNATURE);
mb.appendDUP();
mb.loadContext();
mb.appendCallInterface(UNMARSHALLERPRESENT_METHOD,
UNMARSHALLERPRESENT_SIGNATURE);
iffounds[i] = mb.appendIFNE(this);
mb.appendPOP();
}
// generate code to throw exception if no matching extension
// found
mb.appendCreateNew("java.lang.StringBuffer");
mb.appendDUP();
mb.appendLoadConstant("Element ");
mb.appendCallInit("java.lang.StringBuffer",
"(Ljava/lang/String;)V");
mb.appendDUP();
mb.loadContext(UNMARSHALCONTEXT_CLASS);
mb.appendCallVirtual(CURRENTELEMENT_METHOD,
CURRENTELEMENT_SIGNATURE);
mb.appendCallVirtual("java.lang.StringBuffer.append",
"(Ljava/lang/String;)Ljava/lang/StringBuffer;");
mb.appendDUP();
mb.appendLoadConstant(" has no mapping that extends " +
m_class.getClassName());
mb.appendCallVirtual("java.lang.StringBuffer.append",
"(Ljava/lang/String;)Ljava/lang/StringBuffer;");
mb.appendCallVirtual("java.lang.StringBuffer.toString",
"()Ljava/lang/String;");
mb.appendCreateNew(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
mb.appendDUP_X1();
mb.appendSWAP();
mb.appendCallInit(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS,
MethodBuilder.EXCEPTION_CONSTRUCTOR_SIGNATURE1);
mb.appendThrow();
if (iffounds.length > 0) {
// finish by calling unmarshaller for extension mapping
// found and returning the result with no further
// processing
mb.initStackState(iffounds[0]);
BranchTarget found = mb.appendTargetACONST_NULL();
for (int i = 0; i < iffounds.length; i++) {
iffounds[i].setTarget(found, mb);
}
mb.loadContext();
mb.appendCallInterface(UNMARSHALLERUNMARSHAL_METHOD,
UNMARSHALLERUNMARSHAL_SIGNATURE);
mb.appendReturn("java.lang.Object");
}
// fall into instance creation if this mapping reference
if (ifthis != null) {
mb.targetNext(ifthis);
}
} else if (m_isAbstract) {
// throw an exception when no instance supplied
mb.appendCreateNew(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
mb.appendDUP();
mb.appendLoadConstant("Abstract mapping requires instance to " +
"be supplied for class " + m_class.getClassName());
mb.appendCallInit(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS,
MethodBuilder.EXCEPTION_CONSTRUCTOR_SIGNATURE1);
mb.appendThrow();
}
if (hasname) {
// just create an instance of the (non-abstract) mapped class
mb.appendACONST_NULL();
genNewInstance(mb);
mb.storeObject();
}
// define unmarshallings for child mappings of this mapping
mb.targetNext(ifnnull);
ArrayList maps = m_defContext.getMappings();
if (maps != null && maps.size() > 0) {
for (int i = 0; i < maps.size(); i++) {
IMapping map = (IMapping)maps.get(i);
if (!map.isAbstract() || map.isBase()) {
mb.loadContext(UNMARSHALCONTEXT_CLASS);
mb.appendLoadConstant(map.getMappingName());
NameDefinition mname = map.getName();
if (mname == null) {
mb.appendACONST_NULL();
mb.appendACONST_NULL();
} else {
map.getName().genPushUriPair(mb);
}
mb.appendLoadConstant(map.getUnmarshaller().getName());
mb.appendCallVirtual(ADDUNMARSHALLER_METHOD,
ADDUNMARSHALLER_SIGNATURE);
}
}
}
// load object and cast to type
mb.loadObject();
mb.appendCreateCast(type);
// handle the actual unmarshalling
if (hasattr) {
m_component.genAttributeUnmarshal(mb);
}
if (hasattr || !hasname) {
mb.loadContext(UNMARSHALCONTEXT_CLASS);
mb.appendCallVirtual(PARSERNEXT_METHOD,
PARSERNEXT_SIGNATURE);
mb.appendPOP();
}
if (hascont) {
m_component.genContentUnmarshal(mb);
}
// undefine unmarshallings for child mappings of this mapping
if (maps != null && maps.size() > 0) {
for (int i = 0; i < maps.size(); i++) {
IMapping map = (IMapping)maps.get(i);
if (!map.isAbstract() || map.isBase()) {
mb.loadContext(UNMARSHALCONTEXT_CLASS);
mb.appendLoadConstant(map.getMappingName());
mb.appendCallVirtual(REMOVEUNMARSHALLER_METHOD,
REMOVEUNMARSHALLER_SIGNATURE);
}
}
}
// finish by returning unmarshalled object reference
mb.appendReturn("java.lang.Object");
mb.codeComplete(false);
mb.addMethod();
// add interface if mapped class is directly unmarshallable
if (hasname && m_class.getClassFile() == m_class.getMungedFile()) {
addIUnmarshallableMethod();
}
}
/**
* Generate the {@link
* org.jibx.runtime.IUnmarshaller#isPresent(org.jibx.runtime.IUnmarshallingContext)}
* method implementation.
*
* @param cf class to receive method
* @param hasname element name defined by this mapping flag
*/
private void generateIsPresent(ClassFile cf, boolean hasname) {
// create the method builder
ContextMethodBuilder mb = new ContextMethodBuilder
(ISPRESENT_METHODNAME, Type.BOOLEAN, ISPRESENT_METHOD_ARGS,
cf, Constants.ACC_PUBLIC|Constants.ACC_FINAL, -1, null,
1, UNMARSHALCONTEXT_INTERFACE);
// generate name comparison unless an abstract mapping
if (hasname) {
// test if at defined element name
mb.addException(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
mb.loadContext();
m_name.genPushUriPair(mb);
mb.appendCallInterface(UNMARSHAL_ISATMETHOD,
UNMARSHAL_ISATSIGNATURE);
}
// check for extension mapping handling required
if (m_extensions != null) {
// return immediately if this mapping name check successful
BranchWrapper ifthis = null;
if (hasname) {
ifthis = mb.appendIFNE(this);
}
// build code to check each extension mapping in turn;
// return "true" if one matches, or "false" if none do
mb.addException(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
BranchWrapper[] iffounds =
new BranchWrapper[m_extensions.size()];
for (int i = 0; i < iffounds.length; i++) {
IMapping map = (IMapping)m_extensions.get(i);
mb.loadContext();
mb.appendLoadConstant(map.getMappingName());
mb.appendCallInterface(GETUNMARSHALLER_METHOD,
GETUNMARSHALLER_SIGNATURE);
mb.loadContext();
mb.appendCallInterface(UNMARSHALLERPRESENT_METHOD,
UNMARSHALLERPRESENT_SIGNATURE);
iffounds[i] = mb.appendIFNE(this);
}
mb.appendICONST_0();
mb.appendReturn("int");
mb.initStackState(iffounds[0]);
BranchTarget found = mb.appendTargetLoadConstant(1);
if (ifthis != null) {
ifthis.setTarget(found, mb);
}
for (int i = 0; i < iffounds.length; i++) {
iffounds[i].setTarget(found, mb);
}
} else if (!hasname) {
// mapping with no separate element name, just return "true"
mb.appendICONST_1();
}
mb.appendReturn("int");
mb.codeComplete(false);
mb.addMethod();
}
/**
* Generate the {@link org.jibx.runtime.IMarshaller#marshal(Object,
* org.jibx.runtime.IMarshallingContext)} method implementation.
*
* @param cf class to receive method
* @param hasattr attribute definition present flag
* @param hascont content definition present flag
* @throws JiBXException
*/
private void generateMarshalImplementation(ClassFile cf, boolean hasattr,
boolean hascont) throws JiBXException {
// build the marshal implementation method; this loads the
// passed object and casts it to the target type, then handles
// marshalling first attributes and followed by content for the
// item
ContextMethodBuilder mb = new ContextMethodBuilder
(MARSHAL_METHODNAME, Type.VOID, MARSHAL_METHOD_ARGS, cf,
Constants.ACC_PUBLIC|Constants.ACC_FINAL,
1, "java.lang.Object", 2, MARSHALCONTEXT_INTERFACE);
mb.addException(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
// define marshallings for child mappings of this mapping
ArrayList maps = m_defContext.getMappings();
if (maps != null && maps.size() > 0) {
for (int i = 0; i < maps.size(); i++) {
IMapping map = (IMapping)maps.get(i);
if (!map.isAbstract() || map.isBase()) {
mb.loadContext(MARSHALCONTEXT_CLASS);
mb.appendLoadConstant(map.getMappingName());
mb.appendLoadConstant(map.getMarshaller().getName());
mb.appendCallVirtual(ADDMARSHALLER_METHOD,
ADDMARSHALLER_SIGNATURE);
}
}
}
if (hasattr || hascont) {
// start by pushing namespace translation for precompiled binding
mb.loadContext();
mb.appendLoadConstant(m_container.getBindingRoot().getFactoryName());
mb.appendCallInterface(PUSH_NAMESPACES_METHOD,
PUSH_NAMESPACES_SIG);
// handle the actual marshalling
mb.loadObject(m_class.getClassName());
if (hasattr) {
if (hascont) {
mb.appendDUP();
}
m_component.genAttributeMarshal(mb);
}
if (hasattr || m_isAbstract) {
mb.loadContext(MARSHALCONTEXT_CLASS);
mb.appendCallVirtual(CLOSESTART_METHOD,
CLOSESTART_SIGNATURE);
mb.appendPOP();
}
if (hascont) {
m_component.genContentMarshal(mb);
}
// pop namespace translation for precompiled binding
mb.loadContext();
mb.appendCallInterface(POP_NAMESPACES_METHOD,
POP_NAMESPACES_SIG);
}
// undefine marshallings for child mappings of this mapping
if (maps != null && maps.size() > 0) {
for (int i = 0; i < maps.size(); i++) {
IMapping map = (IMapping)maps.get(i);
if (!map.isAbstract() || map.isBase()) {
mb.loadContext(MARSHALCONTEXT_CLASS);
mb.appendLoadConstant(map.getMappingName());
mb.appendCallVirtual(REMOVEMARSHALLER_METHOD,
REMOVEMARSHALLER_SIGNATURE);
}
}
}
// finish with plain return
mb.appendReturn();
mb.codeComplete(false);
mb.addMethod();
}
public void generateCode(boolean force) throws JiBXException {
// first call code generation for child mappings
m_defContext.generateCode(false, false);
if (!force && m_isAbstract && m_extensions == null) {
return;
}
// create the helper class
BindingDefinition def = m_container.getBindingRoot();
String init = m_class.deriveClassName(def.getPrefix(),
ADAPTERCLASS_SUFFIX);
String name = init;
int loop = 0;
while (ClassCache.hasClassFile(name)) {
name = init + ++loop;
}
ClassFile base = ClassCache.requireClassFile("java.lang.Object");
String[] intfs = def.isInput() ?
(def.isOutput() ? BOTH_INTERFACES : UNMARSHALLER_INTERFACES) :
MARSHALLER_INTERFACES;
ClassFile cf = new ClassFile(name, m_class.getMungedFile().getRoot(),
base, Constants.ACC_PUBLIC, intfs);
cf.addDefaultConstructor();
// add marshaller/unmarshaller implementation methods
boolean hasattr = m_component.hasAttribute();
boolean hascont = m_component.hasContent();
boolean hasname = !m_isAbstract && m_name != null;
if (def.isInput()) {
generateIsPresent(cf, hasname);
generateUnmarshalImplementation(cf, hasattr, hascont, hasname);
}
if (def.isOutput()) {
// generate the basic method
generateMarshalImplementation(cf, hasattr, hascont);
generateIfExtendingCheck(cf, hasname);
// add interface if mapped class is directly marshallable
if (hasname && m_class.getClassFile() == m_class.getMungedFile()) {
addIMarshallableMethod();
}
// check for mapping with extensions to add extra method and
// interface
if (m_extensions != null) {
generateAbstractMarshaller(cf);
}
}
// add as generated class
m_marshaller = m_unmarshaller = MungedClass.getUniqueSupportClass(cf);
}
public NameDefinition getWrapperName() {
return m_name;
}
public void setLinkages() throws JiBXException {
if (!isLinked()) {
super.setLinkages();
m_defContext.setLinkages();
if (m_name != null) {
m_name.fixNamespace(m_defContext);
}
}
}
public ITypeBinding getBinding() {
return m_binding;
}
// DEBUG
public void print(int depth) {
BindingDefinition.indent(depth);
System.out.print("mapping class " + m_class.getClassFile().getName());
if (m_name != null) {
System.out.print(" to element " + m_name.toString());
}
if (m_baseMapping != null) {
System.out.print(" extends " + m_baseMapping.getBoundType());
}
if (m_isAbstract) {
if (m_extensions != null) {
System.out.print(" (abstract, " + m_extensions.size() +
" extensions)");
} else {
System.out.print(" (abstract)");
}
}
System.out.println();
m_defContext.print(depth+1);
m_component.print(depth+1);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/Loader.java 0000644 0001750 0001750 00000032754 11321162042 023335 0 ustar twerner twerner /*
Copyright (c) 2003-2010, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.HashMap;
import org.jibx.binding.classes.BoundClass;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.MungedClass;
import org.jibx.binding.def.BindingDefinition;
import org.jibx.runtime.JiBXException;
import org.jibx.util.ClasspathUrlExtender;
/**
* Binding classloader. This is intended to substitute for the System
* classloader (i.e., the one used for loading user classes). It first processes
* one or more binding definitions, caching the binary classes modified by the
* bindings. It then uses these modified forms of the classes when they're
* requested for loading.
*
* @author Dennis M. Sosnoski
*/
public class Loader extends URLClassLoader
{
/** Binding definitions used by loader. */
private ArrayList m_bindings;
/** Flag for bindings compiled into class code. */
private boolean m_isBound;
/** Map of classes modified by binding. */
private HashMap m_classMap;
/**
* Constructor with classpath URLs and parent classloader supplied. Sets up
* the paths for both actual classloading and finding classes to be bound.
*
* @param paths array of classpath URLs
* @param parent classloader used for delegation loading
*/
public Loader(URL[] paths, ClassLoader parent) {
// configure the base class
super(paths, parent);
m_bindings = new ArrayList();
m_classMap = new HashMap();
// find all the file URLs in path
ArrayList fpaths = new ArrayList(paths.length);
for (int i = 0; i < paths.length; i++) {
URL path = paths[i];
if ("file".equals(path.getProtocol())) {
fpaths.add(path.getPath());
}
}
// set paths to be used for loading referenced classes
String[] dirs = (String[])fpaths.toArray(new String[0]);
ClassCache.setPaths(dirs);
ClassFile.setPaths(dirs);
ClasspathUrlExtender.setClassLoader(ClassFile.getClassLoader());
// reset static information accumulation for binding
BoundClass.reset();
MungedClass.reset();
BindingDefinition.reset();
}
/**
* Constructor with classpath URLs supplied. This uses the supplied
* classpaths, delegating directly to the parent classloader of the normal
* System classloader.
*
* @param paths array of classpath URLs
*/
public Loader(URL[] paths) {
this(paths, ClassLoader.getSystemClassLoader().getParent());
}
/**
* Default constructor. This reads the standard class path and uses it for
* locating classes used by the binding, delegating directly to the parent
* classloader of the normal System classloader.
*
* @exception MalformedURLException on error in classpath URLs
*/
public Loader() throws MalformedURLException {
this(getClassPaths());
}
/**
* Reset loader information. This discards all prior bindings and clears the
* internal state in preparation for loading a different set of bindings. It
* is not possible to clear the loaded classes, though, so any new bindings
* must refer to different classes from those previously loaded.
*/
public void reset() {
m_bindings.clear();
m_classMap.clear();
m_isBound = false;
BoundClass.reset();
MungedClass.reset();
BindingDefinition.reset();
}
/**
* Method builds an array of URL for items in the class path.
*
* @return array of classpath URLs
* @throws MalformedURLException
*/
public static URL[] getClassPaths() throws MalformedURLException {
String[] paths = Utility.getClassPaths();
URL[] urls = new URL[paths.length];
for (int i = 0; i < urls.length; i++) {
urls[i] = new File(paths[i]).toURI().toURL();
}
return urls;
}
/**
* Load binding definition. This may be called multiple times to load
* multiple bindings, but only prior to the bindings being compiled. The
* reader form of the call is generally preferred, since the document
* encoding may not be properly interpreted from a stream.
*
* @param fname binding definition full name
* @param sname short form of name to use as the default name of the binding
* @param is input stream for binding definition document
* @param url URL for binding definition (null if not
* available)
* @exception IllegalStateException if called after bindings have been
* compiled
* @exception IOException if error reading the binding
* @exception JiBXException if error in processing the binding definition
*/
public void loadBinding(String fname, String sname, InputStream is, URL url)
throws JiBXException, IOException {
// error if called after bindings have been compiled
if (m_isBound) {
throw new IllegalStateException
("Call not allowed after bindings compiled");
} else {
m_bindings.add(Utility.loadBinding(fname, sname, is, url, true));
}
}
/**
* Load binding definition from file path. This may be called multiple times
* to load multiple bindings, but only prior to the bindings being compiled.
*
* @param path binding definition file path
* @exception IllegalStateException if called after bindings have been
* compiled
* @exception IOException if error reading the file
* @exception JiBXException if error in processing the binding definition
*/
public void loadFileBinding(String path) throws JiBXException, IOException {
// error if called after bindings have been compiled
if (m_isBound) {
throw new IllegalStateException
("Call not allowed after bindings compiled");
} else {
m_bindings.add(Utility.loadFileBinding(path, true));
}
}
/**
* Load binding definition from file path. This may be called multiple times
* to load multiple bindings, but only prior to the bindings being compiled.
*
* @param path binding definition file path
* @exception IllegalStateException if called after bindings have been
* compiled
* @exception IOException if error reading the file
* @exception JiBXException if error in processing the binding definition
*/
public void loadResourceBinding(String path)
throws JiBXException, IOException {
// error if called after bindings have been compiled
if (m_isBound) {
throw new IllegalStateException
("Call not allowed after bindings compiled");
} else {
String fname = path;
int split = fname.lastIndexOf('/');
if (split >= 0) {
fname = fname.substring(split+1);
}
InputStream is = getResourceAsStream(path);
if (is == null) {
throw new IOException("Resource " + path + " not found");
} else {
String bname = Utility.bindingFromFileName(fname);
loadBinding(fname, bname, is, null);
}
}
}
/**
* Process the binding definitions. This compiles the bindings into the
* classes, saving the modified classes for loading when needed.
*
* @exception JiBXException if error in processing the binding definition
*/
public void processBindings() throws JiBXException {
if (!m_isBound) {
// handle code generation from bindings
int count = m_bindings.size();
for (int i = 0; i < count; i++) {
BindingDefinition binding =
(BindingDefinition)m_bindings.get(i);
binding.generateCode(false, false);
}
// finish binding factories with information on classes used
ClassFile[][] lists = MungedClass.fixDispositions();
for (int i = 0; i < count; i++) {
BindingDefinition binding =
(BindingDefinition)m_bindings.get(i);
binding.addClassList(lists[0], lists[1]);
}
// build hashmap of modified classes
count = lists[0].length;
for (int i = 0; i < count; i++) {
ClassFile clas = lists[0][i];
m_classMap.put(clas.getName(), clas);
}
// finish by setting flag for binding done
m_isBound = true;
}
}
/**
* Check if a class has been modified by a binding. If bindings haven't been
* compiled prior to this call they will be compiled automatically when this
* method is called.
*
* @param name fully qualified package and class name to be found
* @return true if class modified by binding,
* false if not
*/
protected boolean isBoundClass(String name) {
// first complete binding processing if not already done
if (!m_isBound) {
try {
processBindings();
} catch (JiBXException e) {
e.printStackTrace();
}
}
return m_classMap.containsKey(name);
}
/**
* Find and load class by name. If the named class has been modified by a
* binding this loads the modified binary class; otherwise, it just uses the
* base class implementation to do the loading. If bindings haven't been
* compiled prior to this call they will be compiled automatically when this
* method is called.
* @see java.lang.ClassLoader#findClass(java.lang.String)
*
* @param name fully qualified package and class name to be found
* @return the loaded class
* @throws ClassNotFoundException if the class cannot be found
*/
protected Class findClass(String name) throws ClassNotFoundException {
// check if class has been modified by binding
if (isBoundClass(name)) {
try {
// convert class information to byte array
ClassFile clas = (ClassFile)m_classMap.get(name);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
clas.writeFile(bos);
byte[] bytes = bos.toByteArray();
return defineClass(name, bytes, 0, bytes.length);
} catch (IOException e) {
throw new ClassNotFoundException
("Unable to load modified class " + name);
}
} else {
// just use base class handling
return super.findClass(name);
}
}
/**
* Version of bind-on-demand loader which will not delegate handling of
* classes included in the binding definition. Somewhat dangerous to use,
* since it may result in loading multiple versions of the same class
* (with and without binding).
*/
public static class NondelegatingLoader extends Loader
{
/**
* @throws MalformedURLException
*/
public NondelegatingLoader() throws MalformedURLException {
super(getClassPaths(), ClassLoader.getSystemClassLoader());
}
/* (non-Javadoc)
* @see java.lang.ClassLoader#loadClass(java.lang.String, boolean)
*/
protected synchronized Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
if (isBoundClass(name)) {
Class clas = findLoadedClass(name);
if (clas == null) {
clas = findClass(name);
}
return clas;
} else {
return super.loadClass(name, resolve);
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/SchemaGenerator.java 0000644 0001750 0001750 00000117573 11257646712 025224 0 ustar twerner twerner /*
Copyright (c) 2004-2008, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Result;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.model.BindingElement;
import org.jibx.binding.model.CollectionElement;
import org.jibx.binding.model.ContainerElementBase;
import org.jibx.binding.model.DefinitionContext;
import org.jibx.binding.model.ElementBase;
import org.jibx.binding.model.MappingElement;
import org.jibx.binding.model.MappingElementBase;
import org.jibx.binding.model.NestingAttributes;
import org.jibx.binding.model.NestingElementBase;
import org.jibx.binding.model.StructureElement;
import org.jibx.binding.model.StructureElementBase;
import org.jibx.binding.model.TemplateElementBase;
import org.jibx.binding.model.ValidationContext;
import org.jibx.binding.model.ValidationProblem;
import org.jibx.binding.model.ValueElement;
import org.jibx.binding.util.ObjectStack;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.ValidationException;
import org.jibx.util.IClassLocator;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
/**
* Binding generator. This loads the specified input classes and processes them
* to generate a default binding definition.
*
* @author Dennis M. Sosnoski
*/
public class SchemaGenerator
{
/** Generator version. */
private static String CURRENT_VERSION = "0.4";
/** Schema namespace URI. */
private static final String XSD_URI = "http://www.w3.org/2001/XMLSchema";
/** Fixed XML namespace. */
public static final String XML_URI = "http://www.w3.org/XML/1998/namespace";
/** Fixed XML namespace namespace. */
public static final String XMLNS_URI = "http://www.w3.org/2000/xmlns/";
/** Set of object types mapped to schema types. */
private static HashMap s_objectTypeMap = new HashMap();
static {
s_objectTypeMap.put("java.lang.Boolean", "xsd:boolean");
s_objectTypeMap.put("java.lang.Byte", "xsd:byte");
s_objectTypeMap.put("java.lang.Character", "xsd:unsignedInt");
s_objectTypeMap.put("java.lang.Double", "xsd:double");
s_objectTypeMap.put("java.lang.Float", "xsd:float");
s_objectTypeMap.put("java.lang.Integer", "xsd:int");
s_objectTypeMap.put("java.lang.Long", "xsd:long");
s_objectTypeMap.put("java.lang.Short", "xsd:short");
s_objectTypeMap.put("java.math.BigDecimal", "xsd:decimal");
s_objectTypeMap.put("java.math.BigInteger", "xsd:integer");
//#!j2me{
s_objectTypeMap.put("java.sql.Date", "xsd:date");
s_objectTypeMap.put("java.sql.Time", "xsd:time");
s_objectTypeMap.put("java.sql.Timestamp", "xsd:dateTime");
//#j2me}
s_objectTypeMap.put("java.util.Date", "xsd:dateTime");
s_objectTypeMap.put("byte[]", "xsd:base64");
}
/** Set of primitive types mapped to schema types. */
private static HashMap s_primitiveTypeMap = new HashMap();
static {
s_primitiveTypeMap.put("boolean", "xsd:boolean");
s_primitiveTypeMap.put("byte", "xsd:byte");
s_primitiveTypeMap.put("char", "xsd:unsignedInt");
s_primitiveTypeMap.put("double", "xsd:double");
s_primitiveTypeMap.put("float", "xsd:float");
s_primitiveTypeMap.put("int", "xsd:int");
s_primitiveTypeMap.put("long", "xsd:long");
s_primitiveTypeMap.put("short", "xsd:short");
}
/** Show verbose output flag. */
private boolean m_verbose;
/** Use qualified elements default in schema flag. */
private boolean m_isElementQualified;
/** Use qualified attributes default in schema flag. */
private boolean m_isAttributeQualified;
/** Indentation sequence per level of nesting. */
private String m_indentSequence;
/** Map from namespaces to schemas. */
private HashMap m_schemaMap;
/** Locator for finding classes referenced by binding. */
private IClassLocator m_classLocator;
/** Document used for all schema definitions. */
private Document m_document;
/** Stack of structure definitions in progress (used to detect cycles). */
private ObjectStack m_structureStack;
/**
* Constructor with only paths supplied. This just initializes all other
* options disabled.
*
* @param paths class paths to be checked for classes referenced by bindings
*/
public SchemaGenerator(ArrayList paths) {
m_structureStack = new ObjectStack();
m_schemaMap = new HashMap();
// set paths to be used for loading referenced classes
String[] parray = (String[])paths.toArray(new String[paths.size()]);
ClassCache.setPaths(parray);
ClassFile.setPaths(parray);
// set class locator
m_classLocator = new ClassCache.ClassCacheLocator();
try {
// create the document used for all schemas
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setNamespaceAware(true);
m_document = dbf.newDocumentBuilder().newDocument();
} catch (ParserConfigurationException e) {
throw new IllegalStateException("Parser configuration error " +
e.getMessage());
} catch (FactoryConfigurationError e) {
throw new IllegalStateException("Factory configuration error " +
e.getMessage());
}
}
/**
* Constructor with settings specified.
*
* @param verbose report binding details and results
* @param equal use element form default qualified flag
* @param aqual use attribute form default qualified flag
* @param paths class paths to be checked for classes referenced by bindings
*/
public SchemaGenerator(boolean verbose, boolean equal, boolean aqual,
ArrayList paths) {
this(paths);
m_verbose = verbose;
m_isElementQualified = equal;
m_isAttributeQualified = aqual;
m_indentSequence = " ";
}
/**
* Set control flag for verbose processing reports.
*
* @param verbose report verbose information in processing bindings flag
*/
public void setVerbose(boolean verbose) {
m_verbose = verbose;
}
/**
* Set control flag for element qualified default schema.
*
* @param qual element qualified default schemas flag
*/
public void setElementQualified(boolean qual) {
m_isElementQualified = qual;
}
/**
* Set control flag for attribute qualified default schema.
*
* @param qual attribute qualified default schemas flag
*/
public void setAttributeQualified(boolean qual) {
m_isAttributeQualified = qual;
}
/**
* Get array of generated schemas.
*
* @return array of schema elements
*/
public Element[] getSchemas() {
Element[] schemas = new Element[m_schemaMap.size()];
int fill = 0;
for (Iterator iter = m_schemaMap.values().iterator(); iter.hasNext();) {
schemas[fill++] = (Element)iter.next();
}
return schemas;
}
/**
* Generate indentation to proper depth for current item. This creates the
* indentation text and appends it to the supplied parent. The generated
* indentation is appropriate for the close tag of the parent element; if
* a child element is to be added following this indentation it needs to
* use an additional leading indent.
*
* @param parent element to contain indented child item
*/
private void indentForClose(Element parent) {
StringBuffer buff = new StringBuffer(20);
buff.append('\n');
Element ancestor = parent;
boolean count = false;
while (ancestor != null) {
if (count) {
buff.append(m_indentSequence);
}
ancestor = (Element)ancestor.getParentNode();
count = true;
}
parent.appendChild(m_document.createTextNode(buff.toString()));
}
/**
* Add comment with appropriate indentation.
*
* @param parent element to contain indented child item
* @param text comment text
*/
private void addComment(Element parent, String text) {
if (parent.getChildNodes().getLength() == 0) {
indentForClose(parent);
}
parent.appendChild(m_document.createTextNode(m_indentSequence));
parent.appendChild(m_document.createComment(text));
indentForClose(parent);
}
/**
* Add child element with appropriate indentation. This generates and
* returns the child element after adding it to the supplied parent,
* allowing further modification of the new child element.
*
* @param parent element to contain indented child item
* @param name child element name
*/
private Element addChildElement(Element parent, String name) {
if (parent.getChildNodes().getLength() == 0) {
indentForClose(parent);
}
parent.appendChild(m_document.createTextNode(m_indentSequence));
Element element = m_document.createElementNS(XSD_URI, name);
element.setPrefix(parent.getPrefix());
parent.appendChild(element);
indentForClose(parent);
return element;
}
/**
* Get innermost containing definition context.
*
* @return innermost definition context containing this element
*/
public DefinitionContext getDefinitions() {
int index = 0;
while (index < m_structureStack.size()) {
NestingElementBase nest =
(NestingElementBase)m_structureStack.peek(index++);
if (nest.getDefinitions() != null) {
return nest.getDefinitions();
}
}
throw new IllegalStateException
("Internal error: no definition context");
}
/**
* Process a structure component (structure or collection element) with no
* name and no child components. This adds the appropriate type of element
* or any definition to the container schema element.
*
* @param comp structure component to be processed
* @param egroup schema element to contain element definitions
* @param agroup schema element to contain attribute definitions
*/
private void defineEmptyStructureComponent(StructureElementBase comp,
Element egroup, Element agroup) {
NestingElementBase parent =
(NestingElementBase)m_structureStack.peek(0);
boolean only = parent.children().size() == 1;
if (comp.type() == ElementBase.COLLECTION_ELEMENT) {
// collection may define type or not
CollectionElement collection = (CollectionElement)comp;
String itype = collection.getItemTypeClass().getName();
DefinitionContext dctx = getDefinitions();
TemplateElementBase templ = dctx.getSpecificTemplate(itype);
Element element = null;
if (! (templ instanceof MappingElement)) {
if (only) {
addComment(egroup, " Replace \"any\" with details of " +
"content to complete schema ");
element = addChildElement(egroup, "any");
} else {
addComment(egroup,
" No mapping for items of collection at " +
ValidationException.describe(collection) + " ");
addComment(egroup,
" Fill in details of content to complete schema ");
}
} else {
element = addChildElement(egroup, "element");
String name = ((MappingElementBase)templ).getName();
if (element.getPrefix() == null) {
name = "tns:" + name;
}
element.setAttribute("ref", name);
}
if (element != null) {
element.setAttribute("minOccurs", "0");
element.setAttribute("maxOccurs", "unbounded");
}
} else {
// check for reference to a mapped class
StructureElement structure = (StructureElement)comp;
TemplateElementBase templ = structure.getEffectiveMapping();
if (! (templ instanceof MappingElement)) {
// unknown content, leave it to user to fill in details
if (only) {
addComment(egroup, " Replace \"any\" with details of " +
"content to complete schema ");
addChildElement(egroup, "any");
} else {
addComment(egroup, " No mapping for structure at " +
ValidationException.describe(structure) + " ");
addComment(egroup,
" Fill in details of content here to complete schema ");
}
} else {
MappingElementBase mapping = (MappingElementBase)templ;
if (mapping.isAbstract()) {
// check name to be used for instance of type
String ename = structure.getName();
if (ename == null) {
ename = mapping.getName();
}
if (ename == null) {
// no schema equivalent, embed definition directly
addComment(egroup, "No schema representation for " +
"directly-embedded type, inlining definition");
addComment(egroup, "Add element name to structure at " +
ValidationException.describe(structure) +
" to avoid inlining");
defineList(mapping.children(), egroup, agroup, false);
} else {
// handle abstract mapping element as reference to type
Element element = addChildElement(egroup, "element");
String tname = simpleClassName(mapping.getClassName());
if (element.getPrefix() == null) {
tname = "tns:" + tname;
}
element.setAttribute("type", tname);
String name = structure.getName();
if (name == null) {
name = mapping.getName();
}
element.setAttribute("name", name);
if (structure.isOptional()) {
element.setAttribute("minOccurs", "0");
}
}
} else {
// concrete mapping, check for name overridden
String sname = structure.getName();
String mname = mapping.getName();
if (sname != null && !sname.equals(mname)) {
// inline definition for overridden name
addComment(egroup, "No schema representation for " +
"element reference with different name, inlining " +
"definition");
addComment(egroup,
"Remove name on mapping reference at " +
ValidationException.describe(structure) +
" to avoid inlining");
defineList(mapping.children(), egroup, agroup, false);
} else {
// use element reference for concrete mapping
Element element = addChildElement(egroup, "element");
String tname = simpleClassName(mapping.getClassName());
if (element.getPrefix() == null) {
tname = "tns:" + tname;
}
element.setAttribute("ref", tname);
if (structure.isOptional()) {
element.setAttribute("minOccurs", "0");
}
}
}
}
}
}
/**
* Process a structure component (structure or collection element) within a
* list of child components. This adds the appropriate type of element or
* any definition to the container, if necessary calling other methods for
* recursive handling of nested child components.
*
* @param comp structure component to be processed
* @param egroup schema element to contain element definitions
* @param agroup schema element to contain attribute definitions
* @param mult allow any number of occurrences of components flag
*/
private void defineStructureComponent(StructureElementBase comp,
Element egroup, Element agroup, boolean mult) {
// check for element defined by binding component
if (comp.getName() != null) {
// create basic element definition for name
Element element = addChildElement(egroup, "element");
element.setAttribute("name", comp.getName());
if (mult) {
element.setAttribute("minOccurs", "0");
element.setAttribute("maxOccurs", "unbounded");
} else if (comp.isOptional()) {
element.setAttribute("minOccurs", "0");
}
// check for children present
if (comp.children().size() > 0) {
defineNestedStructure(comp, element);
} else {
// nest complex type definition for actual content
Element type = addChildElement(element, "complexType");
Element seq = addChildElement(type, "sequence");
// process the content description
defineEmptyStructureComponent(comp, seq, type);
}
} else if (comp.children().size() > 0) {
// handle child components with recursive call
boolean coll = comp.type() == ElementBase.COLLECTION_ELEMENT;
m_structureStack.push(comp);
defineList(comp.children(), egroup, agroup, coll);
m_structureStack.pop();
} else {
// handle empty structure definition inline
defineEmptyStructureComponent(comp, egroup, agroup);
}
}
/**
* Create the schema definition list for a binding component list. This
* builds the sequence of elements and attributes defined by the binding
* components, including nested complex types for elements with structure.
*
* @param comps binding component list
* @param egroup schema element to contain element definitions
* @param agroup schema element to contain attribute definitions
* @param mult allow any number of occurrences of components flag
*/
private void defineList(ArrayList comps, Element egroup, Element agroup,
boolean mult) {
// handle all nested elements of container
for (int i = 0; i < comps.size(); i++) {
ElementBase child = (ElementBase)comps.get(i);
switch (child.type()) {
case ElementBase.COLLECTION_ELEMENT:
case ElementBase.STRUCTURE_ELEMENT:
{
defineStructureComponent((StructureElementBase)child,
egroup, agroup, mult);
break;
}
case ElementBase.MAPPING_ELEMENT:
{
// nested mapping definitions not handled
System.err.println("Error: nested mapping not supported " +
"(class " + ((MappingElementBase)child).getClassName() +
")");
break;
}
case ElementBase.TEMPLATE_ELEMENT:
{
// templates to be added once usable in binding
System.err.println
("Error: template component not yet supported");
break;
}
case ElementBase.VALUE_ELEMENT:
{
// get type information for value
ValueElement value = (ValueElement)child;
String tname = value.getType().getName();
String stype = (String)s_primitiveTypeMap.get(tname);
if (stype == null) {
stype = (String)s_objectTypeMap.get(tname);
if (stype == null) {
stype = "xsd:string";
}
}
// build schema element or attribute for value
Element element;
int style = value.getStyle();
if (style == NestingAttributes.ATTRIBUTE_STYLE) {
// append attribute as child of type
element = addChildElement(agroup, "attribute");
if (!value.isOptional()) {
element.setAttribute("use", "required");
}
} else if (style == NestingAttributes.ELEMENT_STYLE) {
// append simple element as child of grouping
element = addChildElement(egroup, "element");
if (mult) {
element.setAttribute("minOccurs", "0");
element.setAttribute("maxOccurs", "unbounded");
} else if (value.isOptional()) {
element.setAttribute("minOccurs", "0");
}
} else {
// other types are not currently handled
System.err.println("Error: value type " +
value.getEffectiveStyleName() + " not supported");
break;
}
// set common attributes on definition
element.setAttribute("name", value.getName());
element.setAttribute("type", stype);
break;
}
}
}
}
/**
* Create the schema definition for a nested structure. This defines a
* complex type, if necessary calling itself recursively for elements which
* are themselves complex types. In the special case where the container
* element is a mapping which extends an abstract base class this generates
* the complex type as an extension of the base class complex type.
*
* @param container binding definition element containing nested structure
* @param parent schema element to hold the definition
* @return constructed complex type
*/
private Element defineNestedStructure(ContainerElementBase container,
Element parent) {
// create complex type as holder for definition
Element type = addChildElement(parent, "complexType");
// check whether ordered or unordered container
Element group;
ArrayList childs = container.children();
if (container.isOrdered()) {
// define content list as sequence
group = addChildElement(type, "sequence");
// check for mapping which extends another mapping
/* if (container instanceof MappingElement) {
MappingElement mapping = (MappingElement)container;
MappingElement extended = mapping.getExtendsMapping();
if (extended != null) {
// now see if the mapping can extend base complex type
boolean extend = false;
for (int i = 0; i < childs.size(); i++) {
ElementBase child = (ElementBase)childs.get(i);
if (child instanceof StructureElement) {
StructureElement struct = (StructureElement)child;
if (struct.getMapAsMapping() == extended) {
if (struct.getName() == null) {
extend = true;
}
}
}
if (child instanceof IComponent) {
}
}
}
} */
} else {
group = addChildElement(type, "all");
}
// handle all nested elements of container
m_structureStack.push(container);
defineList(childs, group, type,
container.type() == ElementBase.COLLECTION_ELEMENT);
m_structureStack.pop();
return type;
}
/**
* Generate a schema from a binding using supplied classpaths. If the schema
* for the binding namespace (or default namespace) already exists the
* definitions from this binding are added to the existing schema; otherwise
* a new schema is created and added to the collection defined.
*
* @param binding root element of binding
*/
private void generateSchema(BindingElement binding) {
// process each mapping definition for binding
m_structureStack.push(binding);
ArrayList tops = binding.topChildren();
for (int i = 0; i < tops.size(); i++) {
ElementBase top = (ElementBase)tops.get(i);
if (top.type() == ElementBase.MAPPING_ELEMENT) {
// find or create schema for mapped class
MappingElementBase mapping = (MappingElementBase)top;
String uri = mapping.getNamespace().getUri();
Element schema = (Element)m_schemaMap.get(uri);
if (schema == null) {
// build new schema element for this namespace
schema = m_document.createElementNS(XSD_URI, "schema");
m_schemaMap.put(uri, schema);
// set qualification attributes if needed
if (m_isElementQualified) {
schema.setAttribute("elementFormDefault", "qualified");
}
if (m_isAttributeQualified) {
schema.setAttribute("attributeFormDefault",
"qualified");
}
// add namespace declarations to element
if (uri == null) {
schema.setPrefix("xsd");
} else {
schema.setAttribute("targetNamespace", uri);
schema.setAttributeNS(XMLNS_URI, "xmlns:tns", uri);
schema.setAttributeNS(XMLNS_URI, "xmlns", XSD_URI);
}
schema.setAttributeNS(XMLNS_URI, "xmlns:xsd", XSD_URI);
// add spacing for first child node
indentForClose(schema);
}
// add spacer and comment before actual definition
indentForClose(schema);
String cname = mapping.getClassName();
addComment(schema, " Created from mapping for class " +
cname + " ");
if (mapping.isAbstract()) {
// add mapping as global type in binding
Element type = defineNestedStructure(mapping, schema);
type.setAttribute("name", simpleClassName(cname));
} else {
// add mapping as global element in binding
Element element = addChildElement(schema, "element");
element.setAttribute("name", mapping.getName());
// check type of mapping definition
if (mapping.getMarshaller() != null ||
mapping.getUnmarshaller() != null) {
// use "any" for custom marshaller/unmarshaller
Element type = addChildElement(element, "complexType");
Element seq = addChildElement(type, "sequence");
addComment(seq, " Replace \"any\" with details of " +
"content to complete schema ");
addChildElement(seq, "any");
} else {
// use complex type for embedded definition
defineNestedStructure(mapping, element);
}
}
}
}
m_structureStack.pop();
}
/**
* Process a binding definition for schema generation. This first validates
* the binding definition, and if it is valid then handles schema generation
* from the binding.
*
* @param binding root element of binding
* @exception JiBXException if error in generating the schema
*/
public void generate(BindingElement binding) throws JiBXException {
// validate the binding definition
ValidationContext vctx = new ValidationContext(m_classLocator);
binding.runValidation(vctx);
boolean usable = true;
if (vctx.getProblems().size() > 0) {
// report problems found
System.err.println("Problems found in binding " +
binding.getName());
ArrayList probs = vctx.getProblems();
for (int i = 0; i < probs.size(); i++) {
ValidationProblem prob = (ValidationProblem)probs.get(i);
System.err.println(prob.getDescription());
if (prob.getSeverity() > ValidationProblem.WARNING_LEVEL) {
usable = false;
}
}
}
// check if binding usable for schema generation
if (usable) {
generateSchema(binding);
} else {
System.err.println
("Binding validation errors prevent schema generation");
System.exit(1);
}
}
/**
* Get simple class name.
*
* @param cname class name with full package specification
* @return class name only
*/
private String simpleClassName(String cname) {
int split = cname.lastIndexOf('.');
if (split >= 0) {
cname = cname.substring(split+1);
}
return cname;
}
/**
* Main method for running compiler as application.
*
* @param args command line arguments
*/
public static void main(String[] args) {
if (args.length > 0) {
try {
// check for various flags set
boolean verbose = false;
boolean edflt = true;
boolean adflt = false;
ArrayList paths = new ArrayList();
int offset = 0;
for (; offset < args.length; offset++) {
String arg = args[offset];
if ("-v".equalsIgnoreCase(arg)) {
verbose = true;
} else if ("-e".equalsIgnoreCase(arg)) {
edflt = false;
} else if ("-a".equalsIgnoreCase(arg)) {
adflt = true;
} else if ("-p".equalsIgnoreCase(arg)) {
paths.add(args[++offset]);
} else {
break;
}
}
// set up path and binding lists
String[] vmpaths = Utility.getClassPaths();
for (int i = 0; i < vmpaths.length; i++) {
paths.add(vmpaths[i]);
}
ArrayList bindings = new ArrayList();
for (int i = offset; i < args.length; i++) {
bindings.add(args[i]);
}
// report on the configuration
System.out.println("Running schema generator version " +
CURRENT_VERSION);
if (verbose) {
System.out.println("Using paths:");
for (int i = 0; i < paths.size(); i++) {
System.out.println(" " + paths.get(i));
}
System.out.println("Using input bindings:");
for (int i = 0; i < bindings.size(); i++) {
System.out.println(" " + bindings.get(i));
}
}
// process all specified binding files
SchemaGenerator schemagen = new SchemaGenerator(verbose, edflt,
adflt, paths);
for (int i = 0; i < bindings.size(); i++) {
// read binding from file
String bpath = (String)bindings.get(i);
String name = Utility.fileName(bpath);
File file = new File(bpath);
BindingElement binding = Utility.validateBinding(name,
new URL("file://" + file.getAbsolutePath()),
new FileInputStream(file));
// convert the binding to a schema
if (binding != null) {
schemagen.generate(binding);
}
}
// output each schema to separate file
Element[] schemas = schemagen.getSchemas();
for (int i = 0; i < schemas.length; i++) {
// get base name for output file from last part of namespace
Element schema = schemas[i];
String tns = schema.getAttribute("targetNamespace");
String name = tns;
if (name.length() == 0) {
// fix this to relate back to binding
name = (String)bindings.get(0);
int split = name.lastIndexOf('.');
if (split >= 0) {
name = name.substring(0, split);
}
} else {
int split = name.lastIndexOf('/');
if (split >= 0) {
name = name.substring(split+1);
}
}
try {
// write schema to output file
name += ".xsd";
FileOutputStream out = new FileOutputStream(name);
Transformer transformer =
TransformerFactory.newInstance().newTransformer();
transformer.setOutputProperty("indent", "no");
DOMSource source = new DOMSource(schema);
Result result = new StreamResult(out);
transformer.transform(source, result);
out.close();
System.out.print("Wrote schema " + name);
if (tns.length() == 0) {
System.out.println(" for default namespace");
} else {
System.out.println(" for namespace " + tns);
}
} catch (TransformerConfigurationException e) {
e.printStackTrace();
} catch (TransformerFactoryConfigurationError e) {
e.printStackTrace();
} catch (TransformerException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
} catch (JiBXException ex) {
ex.printStackTrace();
System.exit(1);
} catch (FileNotFoundException e) {
e.printStackTrace();
System.exit(2);
} catch (MalformedURLException e) {
e.printStackTrace();
System.exit(3);
}
} else {
System.out.println
("\nUsage: java org.jibx.binding.SchemaGenerator [-v] [-e]" +
" [-a] [-p path]* binding1 binding2 ...\nwhere:" +
"\n -v turns on verbose output," +
"\n -e sets elementFormDefault=\"false\" for the schemas," +
"\n -a sets attributeFormDefault=\"true\" for the schemas, " +
"and\n -p gives a path component for looking up the classes " +
"referenced in the binding\nThe binding# files are " +
"different bindings to be used for schema generation.\n");
System.exit(1);
}
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/binding/BindingGenerator.java 0000644 0001750 0001750 00000140413 11257646712 025363 0 ustar twerner twerner /*
Copyright (c) 2004-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import org.apache.bcel.classfile.Field;
import org.apache.bcel.classfile.JavaClass;
import org.jibx.binding.classes.ClassCache;
import org.jibx.binding.classes.ClassFile;
import org.jibx.binding.classes.ClassItem;
import org.jibx.binding.model.BindingElement;
import org.jibx.binding.model.CollectionElement;
import org.jibx.binding.model.ContainerElementBase;
import org.jibx.binding.model.MappingElement;
import org.jibx.binding.model.MappingElementBase;
import org.jibx.binding.model.NamespaceElement;
import org.jibx.binding.model.StructureElement;
import org.jibx.binding.model.StructureElementBase;
import org.jibx.binding.model.ValueElement;
import org.jibx.binding.util.ObjectStack;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.JiBXException;
/**
* Binding generator. This loads the specified input classes and processes them
* to generate a default binding definition.
*
* @author Dennis M. Sosnoski
*/
public class BindingGenerator
{
/** Generator version. */
private static String CURRENT_VERSION = "0.4";
/** Set of objects treated as primitives. */
private static HashSet s_objectPrimitiveSet = new HashSet();
static {
s_objectPrimitiveSet.add("java.lang.Boolean");
s_objectPrimitiveSet.add("java.lang.Byte");
s_objectPrimitiveSet.add("java.lang.Character");
s_objectPrimitiveSet.add("java.lang.Double");
s_objectPrimitiveSet.add("java.lang.Float");
s_objectPrimitiveSet.add("java.lang.Integer");
s_objectPrimitiveSet.add("java.lang.Long");
s_objectPrimitiveSet.add("java.lang.Short");
s_objectPrimitiveSet.add("java.math.BigDecimal");
s_objectPrimitiveSet.add("java.math.BigInteger");
//#!j2me{
s_objectPrimitiveSet.add("java.sql.Date");
s_objectPrimitiveSet.add("java.sql.Time");
s_objectPrimitiveSet.add("java.sql.Timestamp");
//#j2me}
s_objectPrimitiveSet.add("java.util.Date");
}
/** Show verbose output flag. */
private boolean m_verbose;
/** Use camel case for XML names flag. */
private boolean m_mixedCase;
/** Namespace URI for elements. */
private String m_namespaceUri;
/** Class names to mapped element names map. */
private HashMap m_mappedNames;
/** Class names to properties list map. */
private HashMap m_beanNames;
/** Class names to deserializers map for typesafe enumerations. */
private HashMap m_enumerationNames;
/** Stack of structure definitions in progress (used to detect cycles). */
private ObjectStack m_structureStack;
/** Class names bound as nested structures. */
private HashSet m_structureNames;
/** Class names to be treated like interfaces (not mapped directly). */
private HashSet m_ignoreNames;
/**
* Default constructor. This just initializes all options disabled.
*/
public BindingGenerator() {
m_mappedNames = new HashMap();
m_structureStack = new ObjectStack();
m_structureNames = new HashSet();
m_ignoreNames = new HashSet();
}
/**
* Constructor with settings specified.
*
* @param verbose report binding details and results
* @param mixed use camel case in element names
* @param uri namespace URI for element bindings
*/
public BindingGenerator(boolean verbose, boolean mixed, String uri) {
this();
m_verbose = verbose;
m_mixedCase = mixed;
m_namespaceUri = uri;
}
/**
* Set control flag for verbose processing reports.
*
* @param verbose report verbose information in processing bindings flag
*/
public void setVerbose(boolean verbose) {
m_verbose = verbose;
}
/**
* Set control flag for camel case element naming.
*
* @param camel use camel case element naming flag
*/
public void setCamelCase(boolean camel) {
m_mixedCase = camel;
}
/**
* Indent to proper depth for current item.
*
* @param pw output print stream to be indented
*/
private void nestingIndent(PrintStream pw) {
for (int i = 0; i < m_structureStack.size(); i++) {
pw.print(' ');
}
}
/**
* Convert class or unprefixed field name to element or attribute name.
*
* @param base class or simple field name to be converted
* @return element or attribute name
*/
private String convertName(String base) {
StringBuffer name = new StringBuffer();
name.append(Character.toLowerCase(base.charAt(0)));
if (m_mixedCase) {
name.append(base.substring(1));
} else {
boolean ignore = true;
for (int i = 1; i < base.length(); i++) {
char chr = base.charAt(i);
if (Character.isUpperCase(chr)) {
chr = Character.toLowerCase(chr);
if (ignore) {
int next = i + 1;
ignore = next >= base.length() ||
Character.isUpperCase(base.charAt(next));
}
if (ignore) {
name.append(chr);
} else {
name.append('-');
name.append(chr);
ignore = true;
}
} else {
name.append(chr);
ignore = false;
}
}
}
return name.toString();
}
/**
* Generate structure element name from class name using set conversions.
*
* @param cname class name to be converted
* @return element name for instances of class
*/
public String elementName(String cname) {
int split = cname.lastIndexOf('.');
if (split >= 0) {
cname = cname.substring(split+1);
}
while ((split = cname.indexOf('$')) >= 0) {
cname = cname.substring(0, split) + cname.substring(split+1);
}
return convertName(cname);
}
/**
* Generate structure element name from class name using set conversions.
*
* @param fname field name to be converted
* @return element name for instances of class
*/
private String valueName(String fname) {
String base = fname;
if (base.startsWith("m_")) {
base = base.substring(2);
} else if (base.startsWith("_")) {
base = base.substring(1);
} else if (base.startsWith("f") && base.length() > 1) {
if (Character.isUpperCase(base.charAt(1))) {
base = base.substring(1);
}
}
return convertName(base);
}
/**
* Construct the list of child binding components that define the binding
* structure for fields of a particular class. This binds all
* non-final/non-static/non-transient fields of the class, if necessary
* creating nested structure elements for unmapped classes referenced by the
* fields.
*
* @param cf class information
* @param contain binding structure container element
* @throws JiBXException on error in binding generation
*/
private void defineFields(ClassFile cf, ContainerElementBase contain)
throws JiBXException {
// process all non-final/non-static/non-transient fields of class
JavaClass clas = cf.getRawClass();
Field[] fields = clas.getFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
if (!field.isFinal() && !field.isStatic() && !field.isTransient()) {
// find type of handling needed for field type
boolean simple = false;
boolean object = true;
boolean attribute = true;
String fname = field.getName();
String tname = field.getType().toString();
if (ClassItem.isPrimitive(tname)) {
simple = true;
object = false;
} else if (s_objectPrimitiveSet.contains(tname)) {
simple = true;
} else if (tname.equals("byte[]")) {
simple = true;
attribute = false;
} else if (tname.startsWith("java.")) {
// check for standard library classes we can handle
ClassFile pcf = ClassCache.requireClassFile(tname);
ClassItem init = pcf.getInitializerMethod
("(Ljava/lang/String;)");
if (init != null) {
simple = pcf.getMethod("toString",
"()Ljava/lang/String;") != null;
attribute = false;
}
}
// check type of handling to use for value
if (m_enumerationNames.get(tname) != null) {
// define a value using deserializer method
String mname = (String)m_enumerationNames.get(tname);
int split = mname.lastIndexOf('.');
ClassFile dcf =
ClassCache.requireClassFile(mname.substring(0, split));
ClassItem dser =
dcf.getStaticMethod(mname.substring(split+1),
"(Ljava/lang/String;)");
if (dser == null || !tname.equals(dser.getTypeName())) {
throw new JiBXException("Deserializer method not " +
"found for enumeration class " + tname);
}
ValueElement value = new ValueElement();
value.setFieldName(fname);
value.setName(valueName(fname));
value.setUsageName("optional");
value.setStyleName("element");
value.setDeserializerName(mname);
contain.addChild(value);
} else if (m_mappedNames.get(tname) != null) {
// use mapping definition for class
StructureElement structure = new StructureElement();
structure.setUsageName("optional");
structure.setFieldName(fname);
if (((String)m_mappedNames.get(tname)).length() == 0) {
// add a name for reference to abstract mapping
structure.setName(elementName(tname));
}
contain.addChild(structure);
if (m_verbose) {
nestingIndent(System.out);
System.out.println("referenced existing binding for " +
tname);
}
} else if (simple) {
// define a simple value
ValueElement value = new ValueElement();
value.setFieldName(fname);
value.setName(valueName(fname));
if (object) {
value.setUsageName("optional");
}
if (!attribute) {
value.setStyleName("element");
}
contain.addChild(value);
} else if (tname.endsWith("[]")) {
// array, check if item type has a mapping
String bname = tname.substring(0, tname.length()-2);
if (m_mappedNames.get(bname) == null) {
// no mapping, use collection with inline structure
// TODO: fill it in
throw new JiBXException("Base element type " + bname +
" must be mapped");
} else {
// mapping for type, use simple collection
CollectionElement collection = new CollectionElement();
collection.setUsageName("optional");
collection.setFieldName(fname);
contain.addChild(collection);
}
} else {
// no defined handling, check for collection vs. structure
ClassFile pcf = ClassCache.requireClassFile(tname);
StructureElementBase element;
if (pcf.isImplements("Ljava/util/List;")) {
// create a collection for list subclass
System.err.println("Warning: field " + fname +
" requires mapped implementation of item classes");
element = new CollectionElement();
element.setComment(" add details of collection items " +
"to complete binding definition ");
element.setFieldName(fname);
// specify factory method if just typed as interface
if ("java.util.List".equals(tname)) {
element.setFactoryName
("org.jibx.runtime.Utility.arrayListFactory");
}
} else if (pcf.isInterface() ||
m_ignoreNames.contains(tname)) {
// create mapping reference with warning for interface
nestingIndent(System.err);
System.err.println("Warning: reference to interface " +
"or abstract class " + tname +
" requires mapped implementation");
element = new StructureElement();
element.setFieldName(fname);
} else {
// handle other types of structures directly
element = createStructure(pcf, fname);
}
// finish with common handling
element.setUsageName("optional");
contain.addChild(element);
}
}
}
}
/**
* Construct the list of child binding components that define the binding
* structure corresponding to properties of a particular class. This binds
* the specified properties of the class, using get/set methods, if
* necessary creating nested structure elements for unmapped classes
* referenced by the properties.
*
* @param cf class information
* @param props list of properties specified for class
* @param internal allow private get/set methods flag
* @param contain binding structure container element
* @throws JiBXException on error in binding generation
*/
private void defineProperties(ClassFile cf, ArrayList props,
boolean internal, ContainerElementBase contain) throws JiBXException {
// process all properties of class
for (int i = 0; i < props.size(); i++) {
String pname = (String)props.get(i);
String base = Character.toUpperCase(pname.charAt(0)) +
pname.substring(1);
String gname = "get" + base;
ClassItem gmeth = cf.getMethod(gname, "()");
if (gmeth == null) {
throw new JiBXException("No method " + gname +
"() found for property " + base + " in class " +
cf.getName());
} else {
String tname = gmeth.getTypeName();
String sname = "set" + base;
String sig = "(" + gmeth.getSignature().substring(2) + ")V";
ClassItem smeth = cf.getMethod(sname, sig);
if (smeth == null) {
throw new JiBXException("No method " + sname + "(" + tname +
") found for property " + base + " in class " +
cf.getName());
} else {
// find type of handling needed for field type
boolean simple = false;
boolean object = true;
boolean attribute = true;
if (ClassItem.isPrimitive(tname)) {
simple = true;
object = false;
} else if (s_objectPrimitiveSet.contains(tname)) {
simple = true;
} else if (tname.equals("byte[]")) {
simple = true;
attribute = false;
} else if (tname.startsWith("java.")) {
// check for standard library classes we can handle
ClassFile pcf = ClassCache.requireClassFile(tname);
if (pcf.getInitializerMethod("()") != null) {
simple = pcf.getMethod("toString",
"()Ljava/lang/String;") != null;
attribute = false;
}
}
if (simple) {
// define a simple value
ValueElement value = new ValueElement();
value.setGetName(gname);
value.setSetName(sname);
value.setName(valueName(pname));
if (object) {
value.setUsageName("optional");
}
if (!attribute) {
value.setStyleName("element");
}
contain.addChild(value);
} else if (m_enumerationNames.get(tname) != null) {
// define a value using deserializer method
String mname = (String)m_enumerationNames.get(tname);
int split = mname.lastIndexOf('.');
ClassFile dcf = ClassCache.
requireClassFile(mname.substring(0, split));
ClassItem dser =
dcf.getStaticMethod(mname.substring(split+1),
"(Ljava/lang/String;)");
if (dser == null || !tname.equals(dser.getTypeName())) {
throw new JiBXException("Deserializer method not " +
"found for enumeration class " + tname);
}
ValueElement value = new ValueElement();
value.setGetName(gname);
value.setSetName(sname);
value.setName(valueName(pname));
value.setUsageName("optional");
value.setStyleName("element");
value.setDeserializerName(mname);
contain.addChild(value);
} else if (m_mappedNames.get(tname) != null) {
// use mapping definition for class
StructureElement structure = new StructureElement();
structure.setUsageName("optional");
structure.setGetName(gname);
structure.setSetName(sname);
if (((String)m_mappedNames.get(tname)).length() == 0) {
// add a name for reference to abstract mapping
structure.setName(elementName(tname));
}
contain.addChild(structure);
if (m_verbose) {
nestingIndent(System.out);
System.out.println
("referenced existing binding for " + tname);
}
} else if (tname.endsWith("[]")) {
// array, only supported for mapped base type
String bname = tname.substring(0, tname.length()-2);
if (m_mappedNames.get(bname) == null) {
throw new JiBXException("Base element type " +
bname + " must be mapped");
} else {
StructureElement structure = new StructureElement();
structure.setUsageName("optional");
structure.setGetName(gname);
structure.setSetName(sname);
structure.setMarshallerName
("org.jibx.extras.TypedArrayMapper");
structure.setUnmarshallerName
("org.jibx.extras.TypedArrayMapper");
contain.addChild(structure);
}
} else {
// no defined handling, check collection vs. structure
ClassFile pcf = ClassCache.requireClassFile(tname);
StructureElementBase element;
if (pcf.isImplements("Ljava/util/List;")) {
// create a collection for list subclass
System.err.println("Warning: property " + pname +
" requires mapped implementation of item " +
"classes");
element = new CollectionElement();
element.setComment(" add details of collection " +
"items to complete binding definition ");
element.setGetName(gname);
element.setSetName(sname);
// specify factory method if just typed as interface
if ("java.util.List".equals(tname)) {
element.setFactoryName("org.jibx.runtime." +
"Utility.arrayListFactory");
}
} else if (pcf.isInterface() ||
m_ignoreNames.contains(tname)) {
// mapping reference with warning for interface
nestingIndent(System.err);
System.err.println("Warning: reference to " +
"interface or abstract class " + tname +
" requires mapped implementation");
element = new StructureElement();
element.setGetName(gname);
element.setSetName(sname);
} else {
// handle other types of structures directly
element = createStructure(pcf, pname);
}
// finish with common handling
element.setUsageName("optional");
contain.addChild(element);
}
}
}
}
}
/**
* Construct the list of child binding components that define the binding
* structure corresponding to a particular class. This binds all
* non-final/non-static/non-transient fields of the class, if necessary
* creating nested structure elements for unmapped classes referenced by the
* fields.
*
* @param cf class information
* @param contain binding structure container element
* @throws JiBXException on error in binding generation
*/
private void defineStructure(ClassFile cf, ContainerElementBase contain)
throws JiBXException {
// process basic fields or property list
Object props = m_beanNames.get(cf.getName());
if (props == null) {
defineFields(cf, contain);
} else {
defineProperties(cf, (ArrayList)props, true, contain);
}
// check if superclass may have data for binding
ClassFile sf = cf.getSuperFile();
String sname = sf.getName();
if (!"java.lang.Object".equals(sname) &&
!m_ignoreNames.contains(sname)) {
if (m_mappedNames.get(sname) != null) {
StructureElement structure = new StructureElement();
structure.setMapAsName(sname);
structure.setName(elementName(sname));
contain.addChild(structure);
} else if (m_beanNames.get(sname) != null) {
defineProperties(sf, (ArrayList)m_beanNames.get(sname),
false, contain);
} else if (sf.getRawClass().getFields().length > 0) {
nestingIndent(System.err);
System.err.println("Warning: fields from base class " + sname +
" of class " + cf.getName() + " not handled by generated " +
"binding; use mapping or specify property list");
contain.setComment(" missing information for base class " +
sname + " ");
}
}
}
/**
* Create the structure element for a particular class. This maps all
* non-final/non-static/non-transient fields of the class, if necessary
* creating nested structures.
*
* @param cf class information
* @param fname name of field supplying reference
* @throws JiBXException on error in binding generation
*/
private StructureElement createStructure(ClassFile cf, String fname)
throws JiBXException {
JavaClass clas = cf.getRawClass();
if (m_verbose) {
nestingIndent(System.out);
System.out.println("creating nested structure definition for " +
clas.getClassName());
}
String cname = clas.getClassName();
for (int i = 0; i < m_structureStack.size(); i++) {
if (cname.equals(m_structureStack.peek(i))) {
StringBuffer buff =
new StringBuffer("Error: recursive use of ");
buff.append(cname);
buff.append(" requires :\n ");
while (i >= 0) {
buff.append(m_structureStack.peek(i--));
buff.append(" -> ");
}
buff.append(cname);
throw new JiBXException(buff.toString());
}
}
if (cname.startsWith("java.")) {
nestingIndent(System.err);
System.err.println("Warning: trying to create structure for " +
cname);
} else if (m_structureNames.contains(cname)) {
nestingIndent(System.err);
System.err.println("Warning: repeated usage of class " +
cname + "; consider adding to mapping list");
} else {
m_structureNames.add(cname);
}
m_structureStack.push(cname);
StructureElement element = new StructureElement();
element.setFieldName(fname);
element.setName(valueName(fname));
defineStructure(cf, element);
if (element.children().isEmpty()) {
throw new JiBXException("No content found for class " + cname);
}
m_structureStack.pop();
if (m_verbose) {
nestingIndent(System.out);
System.out.println("completed nested structure definition for " +
clas.getClassName());
}
return element;
}
/**
* Create the mapping element for a particular class. This maps all
* non-final/non-static/non-transient fields of the class, if necessary
* creating nested structures.
*
* @param cf class information
* @param abstr force abstract mapping flag
* @throws JiBXException on error in binding generation
*/
private MappingElementBase createMapping(ClassFile cf, boolean abstr)
throws JiBXException {
JavaClass clas = cf.getRawClass();
if (m_verbose) {
System.out.println("\nBuilding mapping definition for " +
clas.getClassName());
}
MappingElementBase element = new MappingElement();
element.setAbstract(abstr || clas.isAbstract() || clas.isInterface());
String name = clas.getClassName();
element.setClassName(name);
if (abstr) {
element.setAbstract(true);
} else {
element.setName((String)m_mappedNames.get(name));
}
m_structureStack.push(name);
defineStructure(cf, element);
m_structureStack.pop();
return element;
}
private static boolean isMappable(String cname) {
if ("java.lang.String".equals(cname)) {
return false;
} else if ("java.lang.Object".equals(cname)) {
return false;
} else if (ClassItem.isPrimitive(cname)) {
return false;
} else {
return !s_objectPrimitiveSet.contains(cname);
}
}
/**
* Get the set of data classes passed to or returned by a list of methods
* within a class. The classes returned exclude primitive types, wrappers,
* java.lang.String, and java.lang.Object.
* Exception classes thrown by the methods are also optionally accumulated.
*
* @param cname target class name
* @param mnames method names to be checked
* @param dataset set for accumulation of data classes (optional, data
* classes not recorded if null)
* @param exceptset set for accumulation of exception classes (optional,
* data classes not recorded if null)
* @throws JiBXException on error in loading class information
*/
public static void findClassesUsed(String cname, ArrayList mnames,
HashSet dataset, HashSet exceptset) throws JiBXException {
ClassFile cf = ClassCache.getClassFile(cname);
if (cf != null) {
for (int i = 0; i < mnames.size(); i++) {
String mname = (String)mnames.get(i);
ClassItem mitem = cf.getMethod(mname, "");
if (mitem == null) {
System.err.println("Method " + mname +
" not found in class " + cname);
} else {
if (dataset != null) {
String type = mitem.getTypeName();
if (type != null && isMappable(type)) {
dataset.add(type);
}
String[] args = mitem.getArgumentTypes();
for (int j = 0; j < args.length; j++) {
type = args[j];
if (isMappable(type)) {
dataset.add(args[j]);
}
}
}
if (exceptset != null) {
String[] excepts = mitem.getExceptions();
for (int j = 0; j < excepts.length; j++) {
exceptset.add(excepts[j]);
}
}
}
}
}
}
/**
* Generate a set of bindings using supplied classpaths and class names.
*
* @param names list of class names to be included in binding
* @param abstracts set of classes to be handled with abstract mappings in
* binding
* @param customs map of customized class names to marshaller/unmarshaller
* class names
* @param beans map of class names to supplied lists of properties
* @param enums map of typesafe enumeration classes to deserializer methods
* @param ignores list of non-interface classes to be treated as interfaces
* (no mapping, but mapped subclasses are used at runtime)
* @exception JiBXException if error in generating the binding definition
*/
public BindingElement generate(ArrayList names, HashSet abstracts,
HashMap customs, HashMap beans, HashMap enums, ArrayList ignores)
throws JiBXException {
// print current version information
System.out.println("Running binding generator version " +
CURRENT_VERSION);
// add all classes with mappings to tracking map
m_mappedNames.clear();
for (int i = 0; i < names.size(); i++) {
// make sure class can potentially be handled automatically
boolean drop = false;
String name = (String)names.get(i);
ClassFile cf = ClassCache.requireClassFile(name);
if (cf.isImplements("Ljava/util/List;") ||
cf.isImplements("Ljava/util/Map;")) {
System.err.println("Warning: referenced class " + name +
" is a collection class that cannot be mapped " +
"automatically; dropped from mapped list in binding");
drop = true;
} else if (cf.isInterface()) {
System.err.println("Warning: interface " + name +
" is being handled as abstract mapping");
abstracts.add(name);
drop = true;
} else if (cf.isAbstract()) {
System.err.println("Warning: mapping abstract class " + name +
"; make sure actual subclasses are mapped as extending " +
"this abstract mapping");
abstracts.add(name);
drop = true;
}
if (drop) {
names.remove(i--);
} else {
m_mappedNames.put(name, elementName(name));
}
}
for (Iterator iter = abstracts.iterator(); iter.hasNext();) {
m_mappedNames.put((String)iter.next(), "");
}
for (Iterator iter = customs.keySet().iterator(); iter.hasNext();) {
String name = (String)iter.next();
m_mappedNames.put(name, elementName(name));
}
// create set for ignores
m_ignoreNames.clear();
m_ignoreNames.addAll(ignores);
// create binding with optional namespace
BindingElement binding = new BindingElement();
binding.setStyleName("attribute");
if (m_namespaceUri != null) {
NamespaceElement namespace = new NamespaceElement();
namespace.setComment(" namespace for all elements of binding ");
namespace.setDefaultName("elements");
namespace.setUri(m_namespaceUri);
binding.addTopChild(namespace);
}
// add mapping for each specified class
m_structureStack.clear();
m_structureNames.clear();
m_beanNames = beans;
m_enumerationNames = enums;
for (int i = 0; i < names.size(); i++) {
String cname = (String)names.get(i);
if (!abstracts.contains(cname)) {
ClassFile cf = ClassCache.requireClassFile(cname);
MappingElementBase mapping = createMapping(cf, false);
mapping.setComment(" generated mapping for class " + cname);
binding.addTopChild(mapping);
}
}
for (Iterator iter = abstracts.iterator(); iter.hasNext();) {
String cname = (String)iter.next();
ClassFile cf = ClassCache.requireClassFile(cname);
MappingElementBase mapping = createMapping(cf, true);
mapping.setComment(" generate abstract mapping for class " + cname);
binding.addTopChild(mapping);
}
// finish with custom mapping definitions
for (Iterator iter = customs.keySet().iterator(); iter.hasNext();) {
String cname = (String)iter.next();
String mname = (String)customs.get(cname);
MappingElementBase mapping = new MappingElement();
mapping.setComment(" specified mapping for class " + cname);
mapping.setClassName(cname);
mapping.setName((String)m_mappedNames.get(cname));
mapping.setMarshallerName(mname);
mapping.setUnmarshallerName(mname);
binding.addTopChild(mapping);
}
// list classes handled if verbose
if (m_verbose) {
for (int i = 0; i < names.size(); i++) {
m_structureNames.add(names.get(i));
}
m_structureNames.addAll(customs.keySet());
String[] classes = (String[])m_structureNames.
toArray(new String[m_structureNames.size()]);
Arrays.sort(classes);
System.out.println("\nClasses included in binding:");
for (int i = 0; i < classes.length; i++) {
System.out.println(" " + classes[i]);
}
}
return binding;
}
/**
* Main method for running compiler as application.
*
* @param args command line arguments
*/
public static void main(String[] args) {
if (args.length > 0) {
try {
// check for various flags set
boolean mixed = false;
boolean verbose = false;
String uri = null;
String fname = "binding.xml";
ArrayList paths = new ArrayList();
HashMap enums = new HashMap();
HashSet abstracts = new HashSet();
ArrayList ignores = new ArrayList();
HashMap customs = new HashMap();
HashMap beans = new HashMap();
int offset = 0;
for (; offset < args.length; offset++) {
String arg = args[offset];
if ("-v".equalsIgnoreCase(arg)) {
verbose = true;
} else if ("-b".equalsIgnoreCase(arg)) {
String plist = args[++offset];
int split = plist.indexOf("=");
String bname = plist.substring(0, split);
ArrayList props = new ArrayList();
int base = ++split;
while ((split = plist.indexOf(',', split)) >= 0) {
props.add(plist.substring(base, split));
base = ++split;
}
props.add(plist.substring(base));
beans.put(bname, props);
} else if ("-c".equalsIgnoreCase(arg)) {
String custom = args[++offset];
int split = custom.indexOf('=');
if (split > 0) {
customs.put(custom.substring(0, split),
custom.substring(split+1));
} else {
System.err.println
("Unable to interpret customization " + custom);
}
} else if ("-e".equalsIgnoreCase(arg)) {
String cname;
String mname;
String enumf = args[++offset];
int split = enumf.indexOf('=');
if (split > 0) {
cname = enumf.substring(0, split);
mname = enumf.substring(split+1);
if (mname.indexOf('.') < 0) {
mname = cname + '.' + mname;
}
} else {
cname = enumf;
split = cname.lastIndexOf('.');
if (split >= 0) {
mname = cname + '.' + "get" +
cname.substring(split+1);
} else {
mname = cname + '.' + "get" + cname;
}
}
enums.put(cname, mname);
} else if ("-i".equalsIgnoreCase(arg)) {
ignores.add(args[++offset]);
} else if ("-m".equalsIgnoreCase(arg)) {
mixed = true;
} else if ("-f".equalsIgnoreCase(arg)) {
fname = args[++offset];
} else if ("-n".equalsIgnoreCase(arg)) {
uri = args[++offset];
} else if ("-p".equalsIgnoreCase(arg)) {
paths.add(args[++offset]);
} else if ("-a".equalsIgnoreCase(arg)) {
abstracts.add(args[++offset]);
} else {
break;
}
}
// set up path and binding lists
String[] vmpaths = Utility.getClassPaths();
for (int i = 0; i < vmpaths.length; i++) {
paths.add(vmpaths[i]);
}
ArrayList names = new ArrayList();
for (int i = offset; i < args.length; i++) {
if (!abstracts.contains(args[i])) {
names.add(args[i]);
}
}
// report on the configuration
if (verbose) {
System.out.println("Using paths:");
for (int i = 0; i < paths.size(); i++) {
System.out.println(" " + paths.get(i));
}
System.out.println("Using class names:");
for (int i = 0; i < names.size(); i++) {
System.out.println(" " + names.get(i));
}
if (abstracts.size() > 0) {
System.out.println("Using abstract class names:");
for (Iterator iter = abstracts.iterator();
iter.hasNext();) {
System.out.println(" " + iter.next());
}
}
if (customs.size() > 0) {
System.out.println
("Using custom marshaller/unmarshallers:");
Iterator iter = customs.keySet().iterator();
while (iter.hasNext()) {
String key = (String)iter.next();
System.out.println(" " + customs.get(key) +
" for " + key);
}
}
if (beans.size() > 0) {
System.out.println("Using bean property lists:");
Iterator iter = beans.keySet().iterator();
while (iter.hasNext()) {
String key = (String)iter.next();
System.out.print(" " + key + " with properties:");
ArrayList props = (ArrayList)beans.get(key);
for (int i = 0; i < props.size(); i++) {
System.out.print(i > 0 ? ", " : " ");
System.out.print(props.get(i));
}
}
}
if (enums.size() > 0) {
System.out.println("Using enumeration classes:");
Iterator iter = enums.keySet().iterator();
while (iter.hasNext()) {
String key = (String)iter.next();
System.out.println(" " + key +
" with deserializer " + enums.get(key));
}
}
}
// set paths to be used for loading referenced classes
String[] parray =
(String[])paths.toArray(new String[paths.size()]);
ClassCache.setPaths(parray);
ClassFile.setPaths(parray);
// generate the binding
BindingGenerator generate =
new BindingGenerator(verbose, mixed, uri);
BindingElement binding = generate.generate(names, abstracts,
customs, beans, enums, ignores);
// marshal binding out to file
IBindingFactory bfact =
BindingDirectory.getFactory("normal", BindingElement.class);
IMarshallingContext mctx = bfact.createMarshallingContext();
mctx.setIndent(2);
mctx.marshalDocument(binding, "UTF-8", null,
new FileOutputStream(fname));
} catch (JiBXException ex) {
ex.printStackTrace(System.out);
System.exit(1);
} catch (FileNotFoundException e) {
e.printStackTrace(System.out);
System.exit(2);
}
} else {
System.out.println
("\nUsage: java org.jibx.binding.BindingGenerator [options] " +
"class1 class2 ...\nwhere options are:\n -a abstract class\n" +
" -b bean property class,\n -c custom mapped class,\n" +
" -e enumeration class,\n -f binding file name,\n" +
" -i ignore class,\n -m use mixed case XML names (instead " +
"of hyphenated),\n -n namespace URI,\n -p class " +
"loading path component,\n -v turns on verbose output\n" +
"The class# files are different classes to be included in " +
"binding (references from\nthese classes will also be " +
"included).\n");
System.exit(1);
}
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/binding/Run.java 0000644 0001750 0001750 00000021645 11037046700 022676 0 ustar twerner twerner /*
Copyright (c) 2003-2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import org.jibx.runtime.JiBXException;
/**
* Bind-on-load class runner. This uses a binding loader to compile a binding,
* then loads and calls the main execution class for an application substituting
* the classes modified by the binding.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class Run
{
private static final String BINDING_LIST_RESOURCE = "jibx_bindings.txt";
private static final String DEFAULT_BINDING_RESOURCE = "jibx_binding.xml";
private Run() {}
/**
* Accumulate list of bindings from stream.
*
* @param is stream to be read for list of bindings (one per line)
* @param bindings accumulated collection of bindings
*/
private static void addBindings(InputStream is, ArrayList bindings)
throws IOException {
BufferedReader rdr = new BufferedReader(new InputStreamReader(is));
String line;
while ((line = rdr.readLine()) != null) {
if (line.length() > 0) {
bindings.add(line);
}
}
}
/**
* Main method for bind-on-load handling.
*
* @param args command line arguments
*/
public static void main(String[] args) {
if (args.length >= 1) {
try {
// first get binding definitions and target class information
ArrayList files = new ArrayList();
ArrayList resources = new ArrayList();
int index = 0;
String target = null;
while (index < args.length) {
String arg = args[index++];
if ("-b".equals(arg)) {
if (index < args.length) {
files.add(args[index++]);
} else {
System.err.println("Missing binding file and " +
"target class following '-b'");
}
} else if ("-l".equals(arg)) {
if (index < args.length) {
FileInputStream is =
new FileInputStream(args[index++]);
addBindings(is, files);
is.close();
} else {
System.err.println("Missing binding list file " +
"and target class following '-l'");
}
} else if ("-r".equals(arg)) {
if (index < args.length) {
resources.add(args[index++]);
} else {
System.err.println("Missing binding resource and " +
"target class following '-r'");
}
} else {
target = arg;
break;
}
}
// make sure we have a target class name
if (target != null) {
// save class name and create loader
Loader loader = new Loader();
// check binding resources if no specified bindings
if (files.size() == 0 && resources.size() == 0) {
InputStream is =
loader.getResourceAsStream(BINDING_LIST_RESOURCE);
if (is == null) {
String name = target.replace('.', '/') + "_" +
BINDING_LIST_RESOURCE;
is = loader.getResourceAsStream(name);
}
if (is != null) {
addBindings(is, resources);
is.close();
} else {
String name = DEFAULT_BINDING_RESOURCE;
is = loader.getResourceAsStream(name);
if (is == null) {
name = target.replace('.', '/') + "_" +
DEFAULT_BINDING_RESOURCE;
is = loader.getResourceAsStream(name);
}
if (is != null) {
resources.add(name);
is.close();
}
}
}
// make sure at least one binding has been specified
if (files.size() == 0 && resources.size() == 0) {
System.err.println("No bindings found");
} else {
// compile all bindings
for (int i = 0; i < files.size(); i++) {
loader.loadFileBinding((String)files.get(i));
}
for (int i = 0; i < resources.size(); i++) {
String path = (String)resources.get(i);
InputStream is = loader.getResourceAsStream(path);
if (is == null) {
throw new IOException("Resource " + path +
" not found on classpath");
}
String fname = Utility.fileName(path);
loader.loadBinding(fname,
Utility.bindingFromFileName(fname), is, null);
}
loader.processBindings();
// load the target class using custom class loader
Class clas = loader.loadClass(target);
// invoke the "main" method of the application class
Class[] ptypes = new Class[] { args.getClass() };
Method main = clas.getDeclaredMethod("main", ptypes);
String[] pargs = new String[args.length-index];
System.arraycopy(args, index, pargs, 0, pargs.length);
Thread.currentThread().setContextClassLoader(loader);
main.invoke(null, new Object[] { pargs });
}
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (JiBXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
} else {
System.out.println
("Usage: org.jibx.binding.Run [-b binding-file][-l list-file]" +
"[-r binding-resource] main-class args...");
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/ 0000755 0001750 0001750 00000000000 11526304016 022714 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/ClassCache.java 0000644 0001750 0001750 00000026176 11175704054 025572 0 ustar twerner twerner /*
Copyright (c) 2003-2009, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.classes;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import org.apache.bcel.classfile.Utility;
import org.jibx.binding.model.ClassWrapper;
import org.jibx.runtime.JiBXException;
import org.jibx.util.IClass;
import org.jibx.util.IClassLocator;
/**
* Cache for class files being modified. Handles loading and saving of class
* files. Classes are loaded directly from the file system paths supplied on
* initialization in preference to the system class path.
*
* @author Dennis M. Sosnoski
*/
public class ClassCache
{
/** Singleton instance of class (created when paths set) */
private static ClassCache s_instance;
/** Classes to be preserved without modification. */
private static HashSet s_preserveClasses;
/** Paths to be searched for class files. */
private String[] m_paths;
/** Root directories corresponding to paths. */
private File[] m_roots;
/** Map from class names to actual class information. */
private HashMap m_classMap;
/**
* Constructor. Discards jar file paths and normalizes all other paths
* (except the empty path) to end with the system path separator character.
*
* @param paths ordered set of paths to be searched for class files
*/
private ClassCache(String[] paths) {
ArrayList keepers = new ArrayList();
for (int i = 0; i < paths.length; i++) {
File file = new File(paths[i]);
if (file.isDirectory() && file.canWrite()) {
keepers.add(paths[i]);
}
}
m_paths = new String[keepers.size()];
m_roots = new File[keepers.size()];
for (int i = 0; i < keepers.size(); i++) {
String path = (String)keepers.get(i);
int length = path.length();
if (length > 0) {
if (File.separatorChar != '/') {
path = path.replace('/', File.separatorChar);
}
if (path.charAt(length-1) != File.separatorChar) {
path = path + File.separator;
}
}
m_paths[i] = path;
m_roots[i] = new File(path);
}
m_classMap = new HashMap();
}
/**
* Get class information. Looks up the class in cache, and if not already
* present tries to find it based on the class file search path list. If
* the class file is found it is loaded and this method calls itself
* recursively to load the whole hierarchy of superclasses.
*
* @param name fully-qualified name of class to be found
* @return class information, or null if class not found
* @throws JiBXException on any error accessing class file
*/
private ClassFile getClassFileImpl(String name) throws JiBXException {
// first try for match on fully-qualified class name
Object match = m_classMap.get(name);
if (match != null) {
return (ClassFile)match;
} else if (ClassItem.isPrimitive(name) || name.endsWith("[]")) {
// create synthetic class file for array type
ClassFile cf = new ClassFile(name, Utility.getSignature(name));
m_classMap.put(name, cf);
return cf;
} else {
try {
// got to load it, convert to file path format
ClassFile cf = null;
String path = name.replace('.', File.separatorChar) + ".class";
for (int i = 0; i < m_paths.length; i++) {
// check for file found off search path
File file = new File(m_paths[i], path);
if (file.exists()) {
// load file information
cf = new ClassFile(name, m_roots[i], file);
break;
}
}
// finally try loading (non-modifiable) class from classpath
if (cf == null) {
cf = ClassFile.getClassFile(name);
}
// check for class found
if (cf != null) {
// force loading of superclass as well (to root)
String sname = cf.getSuperName();
if (!name.equals(sname) && sname != null) {
ClassFile sf = getClassFileImpl(sname);
if (sf == null) {
throw new JiBXException("Superclass " + sname +
" of class " + name + " not found");
}
cf.setSuperFile(sf);
}
// add class information to cache
m_classMap.put(name, cf);
}
return cf;
} catch (IOException ex) {
throw new JiBXException("Error loading class " + name);
}
}
}
/**
* Add class name to set to be preserved without modification. If the class
* information has already been loaded, this forces the modifiable setting
* to unmodifiable.
*
* @param name fully-qualified class name
*/
public static void addPreserveClass(String name) {
s_preserveClasses.add(name);
ClassFile cf = (ClassFile)s_instance.m_classMap.get(name);
if (cf != null) {
cf.setUnmodifiable();
}
}
/**
* Check if a class is to be preserved without modification.
*
* @param name fully-qualified class name
* @return true if to be preserved, false if not
*/
public static boolean isPreserveClass(String name) {
return s_preserveClasses.contains(name);
}
/**
* Get class information. Looks up the class in cache, and if not already
* present tries to find it based on the class file search path list. If
* the class file is found it is loaded along with all superclasses.
*
* @param name fully-qualified name of class to be found
* @return class information, or null if class not found
* @throws JiBXException on any error accessing class file
*/
public static ClassFile getClassFile(String name) throws JiBXException {
return s_instance.getClassFileImpl(name);
}
/**
* Get required class information. Looks up the class in cache, and if not
* already present tries to find it based on the class file search path
* list. If the class is not found this throws a runtime exception.
*
* @param name fully-qualified name of class to be found
* @return class information, or null if class not found
* @throws JiBXException on any error accessing class file
*/
public static ClassFile requireClassFile(String name) throws JiBXException {
ClassFile cf = s_instance.getClassFileImpl(name);
if (cf == null) {
throw new IllegalArgumentException("Internal error - class " + name + " not found in classpath");
} else {
return cf;
}
}
/**
* Check if class information has been loaded.
*
* @param name full-qualified name of class to be checked
* @return true if found
*/
public static boolean hasClassFile(String name) {
return s_instance.m_classMap.containsKey(name);
}
/**
* Add created class information to cache.
*
* @param cf information for class to be added
*/
/*package*/ static void addClassFile(ClassFile cf) {
s_instance.m_classMap.put(cf.getName(), cf);
}
/**
* Return the first modifiable directory path from the classpath in use.
*
* @return modifiable directory, or null if none
*/
public static File getModifiablePath() {
if (s_instance.m_roots.length > 0) {
return s_instance.m_roots[0];
} else {
return null;
}
}
/**
* Set class paths to be searched. Discards jar file paths and normalizes
* all other paths (except the empty path) to end with the system path
* separator character.
*
* @param paths ordered set of paths to be searched for class files
*/
public static void setPaths(String[] paths) {
s_preserveClasses = new HashSet();
s_instance = new ClassCache(paths);
}
/**
* Locator using the cache.
*/
public static class ClassCacheLocator implements IClassLocator
{
public boolean isLookupSupported() {
return true;
}
public IClass getClassInfo(String name) {
try {
ClassFile cf = ClassCache.getClassFile(name);
if (cf == null) {
return null;
} else {
return new ClassWrapper(this, cf);
}
} catch (JiBXException e) {
throw new IllegalStateException("Error loading class " + name + ": " + e.getMessage());
}
}
public IClass getRequiredClassInfo(String name) {
IClass iclas = getClassInfo(name);
if (iclas == null) {
throw new IllegalStateException("Internal error: class " + name + " cannot be found");
} else {
return iclas;
}
}
public Class loadClass(String name) {
return ClassFile.loadClass(name);
}
};
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/ClassFile.java 0000644 0001750 0001750 00000220026 11321161744 025430 0 ustar twerner twerner /*
Copyright (c) 2003-2010, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.classes;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import org.apache.bcel.Constants;
import org.apache.bcel.classfile.ClassParser;
import org.apache.bcel.classfile.Code;
import org.apache.bcel.classfile.CodeException;
import org.apache.bcel.classfile.Constant;
import org.apache.bcel.classfile.ConstantDouble;
import org.apache.bcel.classfile.ConstantFloat;
import org.apache.bcel.classfile.ConstantInteger;
import org.apache.bcel.classfile.ConstantLong;
import org.apache.bcel.classfile.ConstantPool;
import org.apache.bcel.classfile.ConstantString;
import org.apache.bcel.classfile.ConstantUtf8;
import org.apache.bcel.classfile.ConstantValue;
import org.apache.bcel.classfile.ExceptionTable;
import org.apache.bcel.classfile.Field;
import org.apache.bcel.classfile.FieldOrMethod;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.classfile.Method;
import org.apache.bcel.classfile.Synthetic;
import org.apache.bcel.classfile.Utility;
import org.apache.bcel.generic.ClassGen;
import org.apache.bcel.generic.ConstantPoolGen;
import org.apache.bcel.generic.FieldGen;
import org.apache.bcel.generic.Type;
import org.apache.bcel.util.ClassPath;
import org.jibx.runtime.JiBXException;
/**
* Class file information. Wraps the actual class file data as well as
* associated management information.
*
* @author Dennis M. Sosnoski
*/
public class ClassFile
{
//
// Constants for code generation.
public static final int PRIVATE_ACCESS = 0;
public static final int PACKAGE_ACCESS = 1;
public static final int PROTECTED_ACCESS = 2;
public static final int PUBLIC_ACCESS = 3;
public static final int SYNTHETIC_ACCESS_FLAG = 0x1000;
protected static final int PRIVATEFIELD_ACCESS =
Constants.ACC_PRIVATE | SYNTHETIC_ACCESS_FLAG;
protected static final ExistingMethod[] EMPTY_METHOD_ARRAY = {};
protected static final byte[] EMPTY_BYTES = new byte[0];
public static final ClassItem[] EMPTY_CLASS_ITEMS = new ClassItem[0];
//
// Class data.
/** Singleton loader from classpath. */
private static ClassPath s_loader;
/** Direct class loader. */
private static URLClassLoader s_directLoader;
//
// Actual instance data.
/** Fully qualified class name. */
private String m_name;
/** Signature for class as type. */
private String m_signature;
/** Class as type. */
private Type m_type;
/** Directory root for class. */
private File m_root;
/** Load path (used to report source of unmodifiable class). */
private String m_path;
/** Actual class file information. */
private File m_file;
/** Class in same package as superclass flag. */
private boolean m_isSamePackage;
/** File is writable flag. */
private boolean m_isWritable;
/** Super class of this class (set by caller, since it may require
additional information to find the class file). */
protected ClassFile m_superClass;
/** Names of all interfaces directly implemented by this class. */
protected String[] m_interfaceNames;
/** Class files of interfaces extended by interface. */
private ClassFile[] m_superInterfaces;
/** All classes and interfaces of which this is an instance (lazy create,
only if needed. */
private String[] m_instanceOfs;
/** All methods defined by this class or interface (lazy create, only if
needed). */
private Method[] m_methods;
/** Base class information as loaded by BCEL. */
private JavaClass m_curClass;
/** Modified class generator (lazy create, only if needed). */
private ClassGen m_genClass;
/** Constant pool generator for modified class (lazy create, only if
needed). */
private ConstantPoolGen m_genPool;
/** Instruction factory for modified class (lazy create, only if needed). */
protected InstructionBuilder m_instBuilder;
/** Map for method names with possibly generated suffixes (lazy create, only
if needed). */
private HashMap m_suffixMap;
/** Map to class item information. */
private HashMap m_itemMap;
/** Flag for class modified. */
private boolean m_isModified;
/** Usage count for this class. */
private int m_useCount;
/** Hash code computation for class is current flag. */
private boolean m_isHashCurrent;
/** Cached hash code value for class. */
private int m_hashCode;
/** Depth of superclass hierarchy for class (lazy computation). */
private int m_inheritDepth;
/** Suffix number for making method names unique (lazy computation). */
private int m_uniqueIndex;
/** Added default constructor for class. */
private ClassItem m_defaultConstructor;
/**
* Constructor for preexisting class file. Loads the class data and
* prepares it for use.
*
* @param name fully qualified class name
* @param root directory root from class loading path list
* @param file actual class file
* @throws IOException if unable to open file
* @throws JiBXException if error in reading class file
*/
public ClassFile(String name, File root, File file)
throws IOException, JiBXException {
init(name, root.getPath(), new FileInputStream(file));
m_root = root;
m_path = root.getAbsolutePath();
m_file = file;
m_isWritable = file.canWrite() && !ClassCache.isPreserveClass(name);
}
/**
* Constructor for synthetic placeholder classfile with no backing class
* data.
*
* @param name fully qualified class name
* @param sig corresponding class signature
*/
public ClassFile(String name, String sig) {
m_path = "";
m_name = name;
m_signature = sig;
m_type = Type.getType(sig);
m_interfaceNames = new String[0];
m_superInterfaces = new ClassFile[0];
m_itemMap = new HashMap();
}
/**
* Constructor for new class file. Initializes the class data and
* prepares it for use.
*
* @param name fully qualified class name
* @param root directory root from class loading path list
* @param sclas superclass of new class
* @param access access flags for class
* @param impls array of interfaces implemented by new class
* (non-null, empty if none)
* @throws JiBXException on error loading interface information
*/
public ClassFile(String name, File root, ClassFile sclas, int access,
String[] impls) throws JiBXException {
String fname = name.replace('.', File.separatorChar)+".class";
File file = new File(root, fname);
m_name = name;
m_signature = Utility.getSignature(name);
m_type = ClassItem.typeFromName(name);
m_root = root;
m_path = "";
m_superClass = sclas;
if (impls == null) {
throw new IllegalArgumentException
("Internal error - non-null array required");
}
m_interfaceNames = impls;
m_file = file;
m_isWritable = true;
m_genClass = new ClassGen(name, sclas.getName(), "",
access | SYNTHETIC_ACCESS_FLAG, impls);
m_genPool = m_genClass.getConstantPool();
int index = m_genPool.addUtf8("Synthetic");
m_genClass.addAttribute(new Synthetic(index, 0, EMPTY_BYTES,
m_genPool.getConstantPool()));
m_instBuilder = new InstructionBuilder(m_genClass, m_genPool);
m_itemMap = new HashMap();
initInterface();
ClassCache.addClassFile(this);
}
/**
* Constructor for preexisting class file from classpath. Loads the class
* data and prepares it for use.
*
* @param name fully qualified class name
* @throws IOException if unable to open file
* @throws JiBXException if error loading superclass or other support file
*/
private ClassFile(String name, ClassPath.ClassFile cf) throws JiBXException,
IOException {
m_path = cf.getBase();
init(name, cf.getPath(), cf.getInputStream());
}
/**
* Constructor for preexisting class file from classpath. Loads the class
* data and prepares it for use.
*
* @param name fully qualified class name
* @return null if unable to find class file
* @throws IOException if error reading file
* @throws JiBXException if error loading superclass or other support file
*/
public static ClassFile getClassFile(String name) throws IOException,
JiBXException {
// try out class path first, then BCEL system path
ClassPath.ClassFile cf = null;
try {
cf = s_loader.getClassFile(name);
} catch (IOException ex) {
try {
cf = ClassPath.SYSTEM_CLASS_PATH.getClassFile(name);
} catch (IOException ex1) { /* deliberately left empty */ }
}
if (cf == null) {
return null;
} else {
return new ClassFile(name, cf);
}
}
/**
* Internal initialization method. This is used to handle common
* initialization for the constructors.
*
* @param name fully qualified class name
* @param path class file path
* @param ins input stream for class file data
* @throws JiBXException if unable to load class file
*/
private void init(String name, String path, InputStream ins)
throws JiBXException {
m_name = name;
m_signature = Utility.getSignature(name);
m_type = ClassItem.typeFromName(name);
m_itemMap = new HashMap();
if (path == null) {
m_interfaceNames = new String[0];
} else {
String fname = name.replace('.', File.separatorChar) + ".class";
ClassParser parser = new ClassParser(ins, fname);
try {
m_curClass = parser.parse();
m_interfaceNames = m_curClass.getInterfaceNames();
if (m_interfaceNames == null) {
m_interfaceNames = new String[0];
}
} catch (Exception ex) {
throw new JiBXException("Error reading path " +
path + " for class " + name);
}
}
initInterface();
}
/**
* Retrieve superinterfaces for an interface class. These are collected at
* initialization so that we can support getting the full set of methods
* later without worrying about throwing an exception.
*
* @throws JiBXException on error loading interface information
*/
private void initInterface() throws JiBXException {
if (isInterface() && m_interfaceNames.length > 0) {
ClassFile[] supers = new ClassFile[m_interfaceNames.length];
for (int i = 0; i < m_interfaceNames.length; i++) {
supers[i] = ClassCache.requireClassFile(m_interfaceNames[i]);
}
m_superInterfaces = supers;
} else {
m_superInterfaces = new ClassFile[0];
}
}
/**
* Check if class is an interface. This only checks existing classes,
* assuming that no generated classes are interfaces.
*
* @return true if an interface, false if not
*/
public boolean isInterface() {
return m_curClass != null && m_curClass.isInterface();
}
/**
* Check if class is abstract. This only checks existing classes,
* assuming that no generated classes are abstract.
*
* @return true if an abstract class, false if not
*/
public boolean isAbstract() {
return m_curClass != null && m_curClass.isAbstract();
}
/**
* Check if class is an array. This only checks existing classes,
* assuming that no generated classes are arrays.
*
* @return true if an array class, false if not
*/
public boolean isArray() {
return m_name.endsWith("[]");
}
/**
* Check if class is modifiable.
*
* @return true if class is modifiable, false if
* not
*/
public boolean isModifiable() {
return m_isWritable && !isInterface();
}
/**
* Get fully qualified class name.
*
* @return fully qualified name for class
*/
public String getName() {
return m_name;
}
/**
* Get signature for class as type.
*
* @return signature for class used as type
*/
public String getSignature() {
return m_signature;
}
/**
* Get class as type.
*
* @return class as type
*/
public Type getType() {
return m_type;
}
/**
* Get package name.
*
* @return package name for class
*/
public String getPackage() {
int split = m_name.lastIndexOf('.');
if (split >= 0) {
return m_name.substring(0, split);
} else {
return "";
}
}
/**
* Get root directory for load path.
*
* @return root directory in path used for loading file
*/
public File getRoot() {
return m_root;
}
/**
* Get actual file for class.
*
* @return file used for class
*/
public File getFile() {
return m_file;
}
/**
* Get raw current class information.
*
* @return raw current class information
*/
public JavaClass getRawClass() {
if (m_curClass == null) {
throw new IllegalStateException
("No loadable class information for " + m_name);
} else {
return m_curClass;
}
}
/**
* Get superclass name.
*
* @return fully qualified name of superclass
*/
public String getSuperName() {
if (m_curClass == null) {
return null;
} else {
return m_curClass.getSuperclassName();
}
}
/**
* Set superclass information.
*
* @param sclas superclass information
*/
public void setSuperFile(ClassFile sclas) {
m_superClass = sclas;
m_isSamePackage = getPackage().equals(sclas.getPackage());
}
/**
* Get superclass information.
*
* @return super class information as loaded (null if no
* superclass - java.lang.Object, interface, or primitive)
*/
public ClassFile getSuperFile() {
return m_superClass;
}
/**
* Get names of all interfaces implemented by class.
*
* @return names of all interfaces implemented directly by class
* (non-null, empty array if none)
*/
public String[] getInterfaces() {
return m_interfaceNames;
}
/**
* Add interface to class. The interface is added to the class if not
* already defined.
*
* @param intf fully qualified interface name
* @return true if added, false if already present
*/
public boolean addInterface(String intf) {
ClassGen gen = getClassGen();
String[] intfs = gen.getInterfaceNames();
for (int i = 0; i < intfs.length; i++) {
if (intf.equals(intfs[i])) {
return false;
}
}
gen.addInterface(intf);
m_isModified = true;
m_instanceOfs = null;
return true;
}
/**
* Accumulate interface signatures recursively.
*
* @param intfs names of interfaces implemented
* @param map map for interfaces already accumulated
* @param accs accumulated interface names
* @throws JiBXException if configuration error
*/
protected void accumulateInterfaces(String[] intfs, HashMap map,
ArrayList accs) throws JiBXException {
for (int i = 0; i < intfs.length; i++) {
String name = intfs[i];
if (map.get(name) == null) {
ClassFile cf = ClassCache.requireClassFile(name);
String sig = cf.getSignature();
map.put(name, sig);
accs.add(sig);
String[] inherits = cf.m_curClass.getInterfaceNames();
accumulateInterfaces(inherits, map, accs);
}
}
}
/**
* Get signatures for all types of which instances of this type are
* instances.
*
* @return all signatures suppored by instances
* @throws JiBXException if configuration error
*/
public String[] getInstanceSigs() throws JiBXException {
if (m_instanceOfs == null) {
// check for an array class
String name = getName();
if (name.endsWith("[]")) {
// accumulate prefix by stripping suffixes
String prefix = "";
do {
name = name.substring(0, name.length()-2);
prefix = prefix + '[';
} while (name.endsWith("[]"));
// check for a primitive base type on array
String[] bsigs;
if (ClassItem.isPrimitive(name)) {
bsigs = new String[1];
bsigs[0] = ClassItem.getPrimitiveSignature(name);
} else {
ClassFile bcf = ClassCache.requireClassFile(name);
bsigs = bcf.getInstanceSigs();
}
// derive array signatures from signatures for base type
String[] asigs = new String[bsigs.length+1];
for (int i = 0; i < bsigs.length; i++) {
asigs[i] = prefix + bsigs[i];
}
asigs[bsigs.length] = "Ljava/lang/Object;";
m_instanceOfs = asigs;
} else {
// walk all classes and interfaces to find signatures
HashMap map = new HashMap();
ArrayList iofs = new ArrayList();
ClassFile cur = this;
while (cur != null) {
String sig = cur.getSignature();
map.put(name, sig);
iofs.add(sig);
accumulateInterfaces(cur.getInterfaces(), map, iofs);
cur = cur.getSuperFile();
}
String[] sigs = new String[iofs.size()];
m_instanceOfs = (String[])iofs.toArray(sigs);
}
}
return m_instanceOfs;
}
/**
* Check if class implements an interface.
*
* @param sig signature of interface to be checked
* @return true if interface is implemented by class,
* false if not
* @throws JiBXException if configuration error
*/
public boolean isImplements(String sig) throws JiBXException {
String[] sigs = getInstanceSigs();
for (int i = 0; i < sigs.length; i++) {
if (sig.equals(sigs[i])) {
return true;
}
}
return false;
}
/**
* Check if another class is a superclass of this one.
*
* @param name of superclass to be checked
* @return true if named class is a superclass of this one,
* false if not
*/
public boolean isSuperclass(String name) {
ClassFile cur = this;
while (cur != null) {
if (cur.getName().equals(name)) {
return true;
} else {
cur = cur.getSuperFile();
}
}
return false;
}
/**
* Get array of fields defined by class.
*
* @return array of fields defined by class
*/
public ClassItem[] getFieldItems() {
if (m_curClass == null) {
return EMPTY_CLASS_ITEMS;
} else {
Field[] fields = m_curClass.getFields();
ClassItem[] items = new ClassItem[fields.length];
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
items[i] = new ClassItem(field.getName(), this, field);
}
return items;
}
}
/**
* Get internal information for field. This can only be used with
* existing classes, and only checks for fields that are actually members
* of the class (not superclasses).
*
* @param name field name
* @return field information, or null if field not found
*/
protected Field getDefinedField(String name) {
// check for match to field name defined in class
Field[] fields = m_curClass.getFields();
for (int i = 0; i < fields.length; i++) {
if (fields[i].getName().equals(name)) {
return fields[i];
}
}
return null;
}
/**
* Get internal information for field. This can only be used with existing
* classes. If the field is not found directly, superclasses are checked for
* inherited fields matching the supplied name.
*
* @param name field name
* @return field information, or null if field not found
*/
protected Field getAccessibleField(String name) {
// always return not found for unloadable class
if (m_curClass == null) {
return null;
} else {
// check for match to field name defined in class
Field field = getDefinedField(name);
if (field == null) {
// try match to field inherited from superclass
if (m_superClass != null) {
field = m_superClass.getAccessibleField(name);
if (field != null && (!m_isSamePackage ||
field.isPrivate()) && !field.isPublic() &&
!field.isProtected()) {
field = null;
}
}
}
return field;
}
}
/**
* Get information for field. This can only be used with existing classes,
* and only checks for fields that are actually members of the class (not
* superclasses).
*
* @param name field name
* @return field information, or null if field not found
*/
public ClassItem getDirectField(String name) {
Field field = getAccessibleField(name);
if (field == null) {
return null;
} else {
ClassItem item = (ClassItem)m_itemMap.get(field);
if (item == null) {
item = new ClassItem(name, this, field);
m_itemMap.put(field, item);
}
return item;
}
}
/**
* Get information for field. This can only be used with existing classes.
* If the field is not found directly, superclasses are checked for
* inherited fields matching the supplied name.
*
* @param name field name
* @return field information
* @throws JiBXException if field not found
*/
public ClassItem getField(String name) throws JiBXException {
Field field = getAccessibleField(name);
if (field == null) {
throw new JiBXException("Field " + name +
" not found in class " + m_name);
} else {
ClassItem item = (ClassItem)m_itemMap.get(field);
if (item == null) {
item = new ClassItem(name, this, field);
m_itemMap.put(field, item);
}
return item;
}
}
/**
* Get array of methods defined by class or interface. In the case of an
* interface, this merges all methods from superinterfaces in the array
* returned.
*
* @return array of methods defined by class
*/
private Method[] getMethods() {
if (m_methods == null) {
// start with methods defined directly
Method[] methods = null;
if (m_genClass != null) {
methods = m_genClass.getMethods();
} else {
methods = m_curClass.getMethods();
}
if (m_curClass.isInterface() && m_superInterfaces.length > 0) {
// for interface extending other interfaces, merge methods
ArrayList merges = new ArrayList();
for (int i = 0; i < methods.length; i++) {
merges.add(methods[i]);
}
for (int i = 0; i < m_superInterfaces.length; i++) {
methods = m_superInterfaces[i].getMethods();
for (int j = 0; j < methods.length; j++) {
merges.add(methods[j]);
}
}
// set merged array
methods = (Method[])merges.toArray(new Method[merges.size()]);
}
// cache the created method array
m_methods = methods;
}
return m_methods;
}
/**
* Get array of methods defined by class.
*
* @return array of methods defined by class
*/
public ClassItem[] getMethodItems() {
if (m_curClass == null) {
return EMPTY_CLASS_ITEMS;
} else {
Method[] methods = getMethods();
ClassItem[] items = new ClassItem[methods.length];
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
items[i] = new ClassItem(method.getName(), this, method);
}
return items;
}
}
/**
* Get internal information for method without respect to potential trailing
* arguments or return value. This can only be used with existing classes.
* If the method is not found directly, superclasses are checked for
* inherited methods matching the supplied name. This compares the supplied
* partial signature against the actual method signature, and considers it
* a match if the actual sigature starts with the supplied signature..
*
* @param name method name
* @param sig partial method signature to be matched
* @return method information, or null if method not found
*/
protected Method getAccessibleMethod(String name, String sig) {
// only check loadable classes
if (m_curClass != null) {
// check for match to method defined in class
Method[] methods = getMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
if (method.getName().equals(name)) {
if (method.getSignature().startsWith(sig)) {
return method;
}
}
}
// try match to method inherited from superclass
if (m_superClass != null) {
Method method = m_superClass.getAccessibleMethod(name, sig);
if (method != null && ((m_isSamePackage &&
!method.isPrivate()) || method.isPublic() ||
method.isProtected())) {
return method;
}
}
}
return null;
}
/**
* Get information for method without respect to potential trailing
* arguments or return value. This can only be used with existing classes.
* If the method is not found directly, superclasses are checked for
* inherited methods matching the supplied name. This compares the supplied
* partial signature against the actual method signature, and considers it
* a match if the actual sigature starts with the supplied signature..
*
* @param name method name
* @param sig partial method signature to be matched
* @return method information, or null if method not found
*/
public ClassItem getMethod(String name, String sig) {
Method method = getAccessibleMethod(name, sig);
if (method == null) {
return null;
} else {
ClassItem item = (ClassItem)m_itemMap.get(method);
if (item == null) {
item = new ClassItem(name, this, method);
m_itemMap.put(method, item);
}
return item;
}
}
/**
* Get information for method matching one of several possible signatures.
* This can only be used with existing classes. If a match is not found
* directly, superclasses are checked for inherited methods matching the
* supplied name and signatures. The signature variations are checked in
* the order supplied.
*
* @param name method name
* @param sigs possible signatures for method (including return type)
* @return method information, or null if method not found
*/
public ClassItem getMethod(String name, String[] sigs) {
Method method = null;
for (int i = 0; method == null && i < sigs.length; i++) {
method = getAccessibleMethod(name, sigs[i]);
}
if (method == null) {
return null;
} else {
ClassItem item = (ClassItem)m_itemMap.get(method);
if (item == null) {
item = new ClassItem(name, this, method);
m_itemMap.put(method, item);
}
return item;
}
}
/**
* Check for match to specified access level. This treats a field or method
* as matching if the access level is the same as or more open than the
* required level.
*
* @param item information for field or method to be checked
* @param access required access level for match
* @return true if access level match, false if
* not
*/
private static boolean matchAccess(FieldOrMethod item, int access) {
if (item.isPublic()) {
return true;
} else if (item.isProtected()) {
return access <= PROTECTED_ACCESS;
} else if (item.isPrivate()) {
return access == PRIVATE_ACCESS;
} else {
return access <= PACKAGE_ACCESS;
}
}
/**
* Check if one type is assignment compatible with another type. This is an
* ugly replacement for apparently broken BCEL code.
*
* @param have type being checked
* @param need type needed
* @return true if compatible, false if not
*/
private static boolean isAssignmentCompatible(Type have, Type need) {
if (have.equals(need)) {
return true;
} else {
try {
return ClassItem.isAssignable(have.toString(), need.toString());
} catch (JiBXException e) {
throw new IllegalStateException
("Internal error: Unable to access data for " +
have.toString() + " or " + need.toString() + ":\n" +
e.getMessage());
}
}
}
/**
* Get information for best matching method. This tries to find a method
* which matches the specified name, return type, and argument types. If an
* exact match is not found it looks for a method with a return type that
* is extended or implemented by the specified type and arguments that are
* extended or implemented by the specified types. This can only be used
* with existing classes. If the method is not found directly, superclasses
* are checked for inherited methods.
*
* @param name method name
* @param access access level required for matching methods
* @param ret return value type (null if indeterminant)
* @param args argument value types (null if indeterminant)
* @return method information, or null if method not found
*/
private Method getBestAccessibleMethod(String name, int access, Type ret,
Type[] args) {
// just fail for classes that aren't loadable
if (m_curClass == null) {
return null;
}
// check for match to method defined in class
Method[] methods = getMethods();
Method best = null;
int diff = Integer.MAX_VALUE;
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
if (method.getName().equals(name) && matchAccess(method, access)) {
// make sure the return type is compatible
boolean match = true;
int ndiff = 0;
if (ret != null) {
Type type = method.getReturnType();
match = isAssignmentCompatible(ret, type);
}
if (match && args != null) {
// check closeness of argument types
Type[] types = method.getArgumentTypes();
if (args.length == types.length) {
for (int j = 0; j < args.length; j++) {
Type type = types[j];
Type arg = args[j];
if (!type.equals(arg)) {
ndiff++;
match = isAssignmentCompatible(arg, type);
if (!match) {
break;
}
}
}
} else {
match = false;
}
}
if (match && ndiff < diff) {
best = method;
}
}
}
if (best != null) {
return best;
}
// try methods inherited from superclass if no match found
if (m_superClass != null) {
if (access < PROTECTED_ACCESS) {
if (m_isSamePackage) {
access = PACKAGE_ACCESS;
} else {
access = PROTECTED_ACCESS;
}
}
return m_superClass.getBestAccessibleMethod(name, access, ret, args);
} else {
return null;
}
}
/**
* Get information for best matching method. This tries to find a method
* which matches the specified name, return type, and argument types. If an
* exact match is not found it looks for a method with a return type that
* is extended or implemented by the specified type and arguments that are
* extended or implemented by the specified types. This can only be used
* with existing classes. If the method is not found directly, superclasses
* are checked for inherited methods.
*
* @param name method name
* @param ret return value type (null if indeterminant)
* @param args argument value types (null if indeterminant)
* @return method information, or null if method not found
*/
public ClassItem getBestMethod(String name, String ret, String[] args) {
Type rtype = null;
if (ret != null) {
rtype = ClassItem.typeFromName(ret);
}
Type[] atypes = null;
if (args != null) {
atypes = new Type[args.length];
for (int i = 0; i < args.length; i++) {
atypes[i] = ClassItem.typeFromName(args[i]);
}
}
Method method =
getBestAccessibleMethod(name, PRIVATE_ACCESS, rtype, atypes);
if (method == null) {
return null;
}
ClassItem item = (ClassItem)m_itemMap.get(method);
if (item == null) {
item = new ClassItem(name, this, method);
m_itemMap.put(method, item);
}
return item;
}
/**
* Get information for initializer. This can only be used with existing
* classes. Only the class itself is checked for an initializer matching
* the argument list signature.
*
* @param sig encoded argument list signature
* @return method information, or null if method not found
*/
public ClassItem getInitializerMethod(String sig) {
// only check if loadable class
if (m_curClass != null) {
// check for match to method defined in class
Method[] methods = getMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
if (method.getName().equals("")) {
if (method.getSignature().startsWith(sig)) {
ClassItem item = (ClassItem)m_itemMap.get(method);
if (item == null) {
item = new ClassItem("", this, method);
m_itemMap.put(method, item);
}
return item;
}
}
}
}
return null;
}
/**
* Get information for static method without respect to return value. This
* can only be used with existing classes. Only the class itself is checked
* for a method matching the supplied name and argument list signature.
*
* @param name method name
* @param sig encoded argument list signature
* @return method information, or null if method not found
*/
public ClassItem getStaticMethod(String name, String sig) {
// only check if loadable class
if (m_curClass != null) {
// check for match to method defined in class
Method[] methods = getMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
if (method.getName().equals(name) && method.isStatic()) {
if (method.getSignature().startsWith(sig)) {
ClassItem item = (ClassItem)m_itemMap.get(method);
if (item == null) {
item = new ClassItem(name, this, method);
m_itemMap.put(method, item);
}
return item;
}
}
}
}
return null;
}
/**
* Get all binding methods currently defined in class. Binding methods are
* generally identified by a supplied prefix, but additional methods
* can be specified the the combination of exact name and signature. This
* is a little kludgy, but necessary to handle the "marshal" method added
* to mapped classes.
*
* @param prefix identifying prefix for binding methods
* @param matches pairs of method name and signature to be matched as
* exceptions to the prefix matching
* @return existing binding methods
*/
public ExistingMethod[] getBindingMethods(String prefix, String[] matches) {
// return empty array if newly created class or unloadable class
if (m_curClass == null) {
return EMPTY_METHOD_ARRAY;
}
// check for binding methods defined in class
Method[] methods = getMethods();
int count = 0;
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
String name = method.getName();
if (name.startsWith(prefix)) {
count++;
} else {
String sig = method.getSignature();
for (int j = 0; j < matches.length; j += 2) {
if (name.equals(matches[j]) && sig.equals(matches[j+1])) {
count++;
break;
}
}
}
}
// generate array of methods found
if (count == 0) {
return EMPTY_METHOD_ARRAY;
} else {
ExistingMethod[] exists = new ExistingMethod[count];
int fill = 0;
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
String name = method.getName();
boolean match = name.startsWith(prefix);
if (!match) {
String sig = method.getSignature();
for (int j = 0; j < matches.length; j += 2) {
if (name.equals(matches[j]) &&
sig.equals(matches[j+1])) {
match = true;
break;
}
}
}
if (match) {
ClassItem item = (ClassItem)m_itemMap.get(method);
if (item == null) {
item = new ClassItem(name, this, method);
m_itemMap.put(method, item);
}
exists[fill++] = new ExistingMethod(method, item, this);
}
}
return exists;
}
}
/**
* Check accessible method. Check if a field or method in another class is
* accessible from within this class.
*
* @param item field or method information
* @return true if accessible, false if not
*/
public boolean isAccessible(ClassItem item) {
if (item.getClassFile() == this) {
return true;
} else {
int access = item.getAccessFlags();
if ((access & Constants.ACC_PUBLIC) != 0) {
return true;
} else if ((access & Constants.ACC_PRIVATE) != 0) {
return false;
} else if (getPackage().equals(item.getClassFile().getPackage())) {
return true;
} else if ((access & Constants.ACC_PROTECTED) != 0) {
ClassFile target = item.getClassFile();
ClassFile ancestor = this;
while ((ancestor = ancestor.getSuperFile()) != null) {
if (ancestor == target) {
return true;
}
}
return false;
} else {
return false;
}
}
}
/**
* Get generator for modifying class.
*
* @return generator for class
*/
private ClassGen getClassGen() {
if (m_genClass == null) {
if (m_isWritable) {
m_genClass = new ClassGen(m_curClass);
m_genPool = m_genClass.getConstantPool();
m_instBuilder = new InstructionBuilder(m_genClass, m_genPool);
m_isHashCurrent = false;
} else {
throw new IllegalStateException("Internal error - cannot modify class " + getName() + " loaded from " + m_path);
}
}
return m_genClass;
}
/**
* Get constant pool generator for modifying class.
*
* @return constant pool generator for class
*/
public ConstantPoolGen getConstPoolGen() {
if (m_genPool == null) {
getClassGen();
}
return m_genPool;
}
/**
* Get instruction builder for modifying class.
*
* @return instruction builder for class
*/
public InstructionBuilder getInstructionBuilder() {
if (m_instBuilder == null) {
getClassGen();
}
return m_instBuilder;
}
/**
* Add method to class.
*
* @param method method to be added
* @return added method information
*/
public ClassItem addMethod(Method method) {
getClassGen().addMethod(method);
setModified();
String mname = method.getName();
if (m_suffixMap != null && isSuffixName(mname)) {
m_suffixMap.put(mname, method);
}
m_methods = null;
return new ClassItem(mname, this, method);
}
/**
* Remove method from class.
*
* @param method method to be removed
*/
public void removeMethod(Method method) {
getClassGen().removeMethod(method);
setModified();
String mname = method.getName();
if (m_suffixMap != null && isSuffixName(mname)) {
m_suffixMap.remove(mname);
}
m_methods = null;
}
/**
* Add field to class with initial String value. If a field
* with the same name already exists, it is overwritten.
*
* @param type fully qualified class name of field type
* @param name field name
* @param access access flags for field
* @param init initial value for field
* @return field information
*/
public ClassItem addField(String type, String name, int access, String init) {
if (init != null && init.length() > 0x7FFF) {
throw new IllegalArgumentException("Internal error - string too long");
}
deleteField(name);
FieldGen fgen = new FieldGen(access,
Type.getType(Utility.getSignature(type)), name, getConstPoolGen());
fgen.setInitValue(init);
Field field = fgen.getField();
getClassGen().addField(field);
m_isModified = true;
m_isHashCurrent = false;
return new ClassItem(name, this, field);
}
/**
* Add field to class with initial int value. If a field with
* the same name already exists, it is overwritten.
*
* @param type fully qualified class name of field type
* @param name field name
* @param access access flags for field
* @param init initial value for field
* @return field information
*/
public ClassItem addField(String type, String name, int access, int init) {
deleteField(name);
FieldGen fgen = new FieldGen(access,
Type.getType(Utility.getSignature(type)), name, getConstPoolGen());
fgen.setInitValue(init);
Field field = fgen.getField();
getClassGen().addField(field);
m_isModified = true;
m_isHashCurrent = false;
return new ClassItem(name, this, field);
}
/**
* Update class field with initial String value. If the field
* already exists with the same characteristics it is left unchanged;
* otherwise any existing field with the same name is overwritten.
*
* @param type fully qualified class name of field type
* @param name field name
* @param access access flags for field
* @param init initial value for field
* @return field information
*/
public ClassItem updateField(String type, String name, int access,
String init) {
// make sure the string length is acceptable
if (init.length() > 0x7FFF) {
throw new IllegalArgumentException("Internal error - string too long");
}
// first check for match with existing field
Field[] fields = m_curClass.getFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
if (field.getName().equals(name) &&
field.getAccessFlags() == access) {
String sig = field.getSignature();
if (type.equals(Utility.signatureToString(sig, false))) {
ConstantValue cval = field.getConstantValue();
if (cval != null) {
int index = cval.getConstantValueIndex();
ConstantPool cp = m_curClass.getConstantPool();
Constant cnst = cp.getConstant(index);
if (cnst instanceof ConstantString) {
Object value = ((ConstantString)cnst).
getConstantValue(cp);
if (init.equals(value)) {
return new ClassItem(name,this, field);
}
}
}
}
}
}
// no exact match, so replace any existing field with same name
deleteField(name);
FieldGen fgen = new FieldGen(access,
Type.getType(Utility.getSignature(type)), name, getConstPoolGen());
fgen.setInitValue(init);
Field field = fgen.getField();
getClassGen().addField(field);
m_isModified = true;
m_isHashCurrent = false;
return new ClassItem(name, this, field);
}
/**
* Add field to class without initialization. If a field with the same name
* already exists, it is overwritten.
*
* @param type fully qualified class name of field type
* @param name field name
* @param access access flags for field
* @return field information
*/
public ClassItem addField(String type, String name, int access) {
deleteField(name);
FieldGen fgen = new FieldGen(access,
Type.getType(Utility.getSignature(type)), name, getConstPoolGen());
Field field = fgen.getField();
getClassGen().addField(field);
m_isModified = true;
m_isHashCurrent = false;
return new ClassItem(name, this, field);
}
/**
* Add private field to class without initialization. If a field
* with the same name already exists, it is overwritten.
*
* @param type fully qualified class name of field type
* @param name field name
* @return field information
*/
public ClassItem addPrivateField(String type, String name) {
return addField(type, name, PRIVATEFIELD_ACCESS);
}
/**
* Add default constructor to a class. The added default constructor just
* calls the default constructor for the superclass. If the superclass
* doesn't have a default constructor, this method is called recursively to
* add one if possible.
*
* @return constructor information
*/
public ClassItem addDefaultConstructor() {
if (m_defaultConstructor == null) {
// check for default constructor in superclass
ClassItem cons = m_superClass.getInitializerMethod("()V");
if (cons == null) {
cons = m_superClass.addDefaultConstructor();
}
cons.makeAccessible(this);
// add the public constructor method
ExceptionMethodBuilder mb = new ExceptionMethodBuilder("",
Type.VOID, new Type[0], this, Constants.ACC_PUBLIC);
// call the superclass constructor
mb.appendLoadLocal(0);
mb.appendCallInit(m_superClass.getName(), "()V");
// finish with return
mb.appendReturn();
mb.codeComplete(false);
m_defaultConstructor = mb.addMethod();
}
return m_defaultConstructor;
}
/**
* Check if a method name matches the pattern for a generated unique suffix.
*
* @param name method name to be checked
* @return true if name matches suffix pattern,
* false if not
*/
private static boolean isSuffixName(String name) {
int last = name.length() - 1;
for (int i = last; i > 0; i--) {
char chr = name.charAt(i);
if (chr == '_') {
return i < last;
} else if (!Character.isDigit(chr)) {
break;
}
}
return false;
}
/**
* Make method name unique with generated suffix. The suffixed method name
* is tracked so that it will not be used again.
*
* @param name base name before suffix is appended
* @return name with unique suffix appended
*/
public String makeUniqueMethodName(String name) {
// check if map creation is needed
if (m_suffixMap == null) {
m_suffixMap = new HashMap();
if (m_curClass != null) {
Method[] methods = getMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
String mname = method.getName();
if (isSuffixName(mname)) {
m_suffixMap.put(mname, method);
}
}
}
}
// check if inheritance depth is needed
if (m_inheritDepth == 0) {
ClassFile cf = this;
while ((cf = cf.getSuperFile()) != null) {
m_inheritDepth++;
}
}
// generate suffix to make name unique, trying low values first
while (true) {
String uname = name + '_' + m_inheritDepth + '_' + m_uniqueIndex;
if (m_suffixMap.get(uname) == null) {
return uname;
} else {
m_uniqueIndex++;
}
}
}
/**
* Delete field from class.
*
* @param name field name
* @return true if field was present, false if not
*/
public boolean deleteField(String name) {
ClassGen cg = getClassGen();
Field field = cg.containsField(name);
if (field == null) {
return false;
} else {
cg.removeField(field);
m_isModified = true;
m_isHashCurrent = false;
return true;
}
}
/**
* Delete method from class.
*
* @param name method name
* @param sig method signature
* @return true if method was present, false if not
*/
public boolean deleteMethod(String name, String sig) {
ClassGen cg = getClassGen();
Method method = cg.containsMethod(name, sig);
if (method == null) {
return false;
} else {
cg.removeMethod(method);
m_isModified = true;
m_isHashCurrent = false;
return true;
}
}
/**
* Get use count for class.
*
* @return use count for this class
*/
public int getUseCount() {
return m_useCount;
}
/**
* Increment use count for class.
*
* @return use count (after increment)
*/
public int incrementUseCount() {
return ++m_useCount;
}
/**
* Force class to unmodifiable state. This prevents any additions, changes,
* deletions to the file.
*/
public void setUnmodifiable() {
if (m_isModified) {
throw new IllegalStateException("Internal error - attempt to preserve already modified file");
} else {
m_isWritable = false;
}
}
/**
* Check if class has been modified.
*
* @return true if class is modified, false if not
*/
public boolean isModified() {
return m_isModified;
}
/**
* Set class modified flag.
*/
public void setModified() {
if (!m_isModified) {
if (m_isWritable) {
m_isModified = true;
MungedClass.addModifiedClass(this);
} else {
throw new IllegalStateException("Internal error - attempt to modify unmodifiable file");
}
}
}
/**
* Check if class is in complete state.
*
* @return true if class is complete, false if not
*/
public boolean isComplete() {
return m_genClass == null;
}
/**
* Computes a hash code based on characteristics of the class. The
* characteristics used in computing the hash code include the base class,
* implemented interfaces, method names, field names, and package, but not
* the actual class name or signature. The current static version of the
* class is used for this computation, so if the class is being modified
* {@link #codeComplete} should be called before this method. Note that this
* is designed for use with the classes generated by JiBX, and is not
* necessarily a good model for general usage.
*
* @return computed hash code value
*/
protected int computeHashCode() {
// start with basic characteristics of class
int hash = getPackage().hashCode();
ClassFile sfile = getSuperFile();
if (sfile != null) {
hash += sfile.getName().hashCode();
}
String[] intfs = getInterfaces();
for (int i = 0; i < intfs.length; i++) {
hash += intfs[i].hashCode();
}
hash += m_curClass.getAccessFlags();
// include field and method names
Field[] fields = m_curClass.getFields();
for (int i = 0; i < fields.length; i++) {
hash = hash * 49 + fields[i].getName().hashCode();
}
Method[] methods = m_curClass.getMethods();
for (int i = 0; i < methods.length; i++) {
hash = hash * 49 + methods[i].getName().hashCode();
}
// finish with constant table simple values (except name and signature)
Constant[] cnsts = m_curClass.getConstantPool().getConstantPool();
for (int i = m_curClass.getClassNameIndex()+1; i < cnsts.length; i++) {
Constant cnst = cnsts[i];
if (cnst != null) {
int value = 0;
switch (cnst.getTag()) {
case Constants.CONSTANT_Double:
value = (int)Double.doubleToRawLongBits
(((ConstantDouble)cnst).getBytes());
break;
case Constants.CONSTANT_Float:
value = Float.floatToRawIntBits
(((ConstantFloat)cnst).getBytes());
break;
case Constants.CONSTANT_Integer:
value = ((ConstantInteger)cnst).getBytes();
break;
case Constants.CONSTANT_Long:
value = (int)((ConstantLong)cnst).getBytes();
break;
case Constants.CONSTANT_Utf8:
String text = ((ConstantUtf8)cnst).getBytes();
if (!text.equals(m_signature)) {
value = text.hashCode();
}
break;
default:
break;
}
hash = hash * 49 + value;
}
}
// System.out.println("Hashed " + m_name + " to value " + hash);
return hash;
}
/**
* Finalize current modified state of class. This converts the modified
* class state into a static form, then computes a hash code based on
* characteristics of the class. If the class has not been modified it
* just computes the hash code. Note that this won't initialize the array
* of superinterfaces if used with an interface, but that shouldn't be a
* problem since we don't create any interfaces.
*/
public void codeComplete() {
if (m_genClass != null) {
m_curClass = m_genClass.getJavaClass();
m_interfaceNames = m_curClass.getInterfaceNames();
if (m_interfaceNames == null) {
m_interfaceNames = new String[0];
}
m_superInterfaces = new ClassFile[0];
m_genClass = null;
}
}
/**
* Get hash code. This is based on most characteristics of the class,
* including the actual methods, but excluding the class name. It is only
* valid after the {@link #codeComplete} method is called.
*
* @return hash code based on code sequence
*/
public int hashCode() {
if (!m_isHashCurrent) {
if (m_genClass != null) {
throw new IllegalStateException
("Class still being constructed");
}
m_hashCode = computeHashCode();
m_isHashCurrent = true;
}
return m_hashCode;
}
/**
* Compare two field or method items to see if they're equal. This handles
* only the comparisons that apply to both fields and methods. It does not
* include comparing access flags, since these may be different due to
* access requirements.
*
* @param a first field or method item
* @param b second field or method item
* @return true if the equal, false if not
*/
public static boolean equalFieldOrMethods(FieldOrMethod a,
FieldOrMethod b) {
return a.getName().equals(b.getName()) &&
a.getSignature().equals(b.getSignature());
}
/**
* Compare two methods to see if they're equal. This checks only the details
* of the exception handling and actual code, not the name or signature.
*
* @param a first method
* @param b second method
* @return true if the equal, false if not
*/
public static boolean equalMethods(Method a, Method b) {
// check the exceptions thrown by the method
ExceptionTable etaba = a.getExceptionTable();
ExceptionTable etabb = b.getExceptionTable();
if (etaba != null && etabb != null) {
String[] aexcepts = etaba.getExceptionNames();
String[] bexcepts = etabb.getExceptionNames();
if (!Arrays.equals(aexcepts, bexcepts)) {
return false;
}
} else if (etaba != null || etabb != null) {
return false;
}
// compare the exception handling details
Code acode = a.getCode();
Code bcode = b.getCode();
CodeException[] acexs = acode.getExceptionTable();
CodeException[] bcexs = bcode.getExceptionTable();
if (acexs.length == bcexs.length) {
for (int i = 0; i < acexs.length; i++) {
CodeException acex = acexs[i];
CodeException bcex = bcexs[i];
if (acex.getCatchType() != bcex.getCatchType() ||
acex.getStartPC() != bcex.getStartPC() ||
acex.getEndPC() != bcex.getEndPC() ||
acex.getHandlerPC() != bcex.getHandlerPC()) {
return false;
}
}
}
// finally compare the actual byte codes
return Arrays.equals(acode.getCode(), bcode.getCode());
}
/**
* Check if objects are equal. Compares first based on hash code, then on
* the actual contents of the class, including package, implemented
* interfaces, superclass, methods, and fields (but not the actual class
* name). It is only valid after the {@link #codeComplete} method is called.
*
* @param obj
* @return true if equal objects, false if not
*/
public boolean equals(Object obj) {
if (obj instanceof ClassFile && obj.hashCode() == hashCode()) {
// check basic details of the classes
ClassFile comp = (ClassFile)obj;
if (!org.jibx.runtime.Utility.isEqual(getPackage(),
comp.getPackage()) || getSuperFile() != comp.getSuperFile() ||
!Arrays.equals(getInterfaces(), comp.getInterfaces())) {
return false;
}
JavaClass tjc = m_curClass;
JavaClass cjc = comp.m_curClass;
if (tjc.getAccessFlags() != cjc.getAccessFlags()) {
return false;
}
// compare the defined fields
Field[] tfields = tjc.getFields();
Field[] cfields = cjc.getFields();
if (tfields.length != cfields.length) {
return false;
}
for (int i = 0; i < tfields.length; i++) {
if (!equalFieldOrMethods(tfields[i], cfields[i])) {
return false;
}
}
// compare the defined methods
Method[] tmethods = tjc.getMethods();
Method[] cmethods = cjc.getMethods();
if (tmethods.length != cmethods.length) {
return false;
}
for (int i = 0; i < tmethods.length; i++) {
Method tmethod = tmethods[i];
Method cmethod = cmethods[i];
if (!equalFieldOrMethods(tmethod, cmethod) ||
!equalMethods(tmethod, cmethod)) {
return false;
}
}
// finish with constant table values (correcting name and signature)
Constant[] tcnsts = tjc.getConstantPool().getConstantPool();
Constant[] ccnsts = cjc.getConstantPool().getConstantPool();
if (tcnsts.length != ccnsts.length) {
return false;
}
for (int i = tjc.getClassNameIndex()+1; i < tcnsts.length; i++) {
Constant tcnst = tcnsts[i];
Constant ccnst = ccnsts[i];
if (tcnst != null && ccnst != null) {
int tag = tcnst.getTag();
if (tag != ccnst.getTag()) {
return false;
}
boolean equal = true;
switch (tag) {
case Constants.CONSTANT_Double:
equal = ((ConstantDouble)tcnst).getBytes() ==
((ConstantDouble)ccnst).getBytes();
break;
case Constants.CONSTANT_Float:
equal = ((ConstantFloat)tcnst).getBytes() ==
((ConstantFloat)ccnst).getBytes();
break;
case Constants.CONSTANT_Integer:
equal = ((ConstantInteger)tcnst).getBytes() ==
((ConstantInteger)ccnst).getBytes();
break;
case Constants.CONSTANT_Long:
equal = ((ConstantLong)tcnst).getBytes() ==
((ConstantLong)ccnst).getBytes();
break;
case Constants.CONSTANT_Utf8:
String ttext = ((ConstantUtf8)tcnst).getBytes();
String ctext = ((ConstantUtf8)ccnst).getBytes();
if (ttext.equals(m_signature)) {
equal = ctext.equals(comp.m_signature);
} else {
equal = ttext.equals(ctext);
}
break;
default:
break;
}
if (!equal) {
return false;
}
} else if (tcnst != null || ccnst != null) {
return false;
}
}
// if nothing failed, the classes are equal
return true;
} else {
return false;
}
}
/**
* Delete class file information. Deletes the class file for this class,
* if it exists. Does nothing if no class file has been generated.
*/
public void delete() {
if (m_file.exists()) {
m_file.delete();
}
}
/**
* Write out modified class information. Writes the modified class file to
* an output stream.
*
* @param os output stream for writing modified class
* @throws IOException if error writing to file
*/
public void writeFile(OutputStream os) throws IOException {
codeComplete();
m_curClass.dump(new BufferedOutputStream(os));
os.close();
}
/**
* Write out modified class information. Writes the modified class file
* back out to the original file. If the class file has not been modified,
* the original file is kept unchanged.
*
* @throws IOException if error writing to file
*/
public void writeFile() throws IOException {
if (m_isModified) {
OutputStream os = new FileOutputStream(m_file);
writeFile(os);
}
}
/**
* Derive generated class name. This generates a JiBX class name from the
* name of this class, using the supplied prefix and suffix information. The
* derived class name is always in the same package as this class.
*
* @param prefix generated class name prefix
* @param suffix generated class name suffix
* @return derived class name
*/
public String deriveClassName(String prefix, String suffix) {
String pack = "";
String tname = m_name;
int split = tname.lastIndexOf('.');
if (split >= 0) {
pack = tname.substring(0, split+1);
tname = tname.substring(split+1);
}
return pack + prefix + tname + suffix;
}
/**
* Set class paths to be searched.
*
* @param paths ordered set of paths to be searched for class files
*/
public static void setPaths(String[] paths) {
// create full path string with separators for BCEL loader
StringBuffer full = new StringBuffer();
for (int i = 0; i < paths.length; i++) {
if (i > 0) {
full.append(File.pathSeparatorChar);
}
full.append(paths[i]);
}
s_loader = new ClassPath(full.toString());
// create direct classloader for access to classes during binding
URL[] urls = new URL[paths.length];
try {
// generate array of component file or directory URLs
for (int i = 0; i < urls.length; i++) {
urls[i] = new File(paths[i]).toURI().toURL();
}
// initialize classloader with full array of path URLs
s_directLoader = new URLClassLoader(urls,
ClassFile.class.getClassLoader());
} catch (MalformedURLException ex) {
throw new IllegalArgumentException
("Error initializing classloading: " + ex.getMessage());
}
}
/**
* Try loading class from classpath.
*
* @param name fully qualified name of class to be loaded
* @return loaded class, or null if not found
*/
public static Class loadClass(String name) {
try {
return s_directLoader.loadClass(name);
} catch (ClassNotFoundException ex) {
return null;
}
}
/**
* Get the classloader used for classes referenced in the binding.
*
* @return classloader
*/
public static ClassLoader getClassLoader() {
return s_directLoader;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/UnmarshalBuilder.java 0000644 0001750 0001750 00000012007 11033613304 027014 0 ustar twerner twerner /*
Copyright (c) 2003-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.classes;
import org.apache.bcel.Constants;
import org.apache.bcel.generic.InstructionHandle;
import org.apache.bcel.generic.ObjectType;
import org.apache.bcel.generic.Type;
/**
* Unmarshalling method builder. Tracks the creation of an unmarshalling method,
* including special handling of exceptions that may be generated by object
* accesses during the unmarshalling process.
*
* @author Dennis M. Sosnoski
*/
public class UnmarshalBuilder extends MarshalUnmarshalBuilder
{
//
// Constants for code generation.
private static final String UNMARSHALCONTEXT_CLASS =
"org.jibx.runtime.impl.UnmarshallingContext";
protected static final String UNMARSHAL_EXCEPTION_TEXT =
"Error while unmarshalling ";
protected static final String UNMARSHALLING_POSITION_METHOD =
"org.jibx.runtime.impl.UnmarshallingContext.buildPositionString";
protected static final String UNMARSHALLING_POSITION_SIGNATURE =
"()Ljava/lang/String;";
private static final Type UNMARSHALCONTEXT_TYPE =
new ObjectType(UNMARSHALCONTEXT_CLASS);
protected static final Type[] SINGLE_STRING_ARGS =
{
Type.STRING
};
/**
* Constructor. This sets up for constructing a static unmarshalling method
* with public access and wrapped exception handling.
*
* @param name method name to be built
* @param cf unmarshal class file information
* @param mf method generation class file information
*/
public UnmarshalBuilder(String name, ClassFile cf, ClassFile mf) {
super(name, cf.getType(),
new Type[] { cf.getType(), UNMARSHALCONTEXT_TYPE}, mf,
Constants.ACC_PUBLIC | Constants.ACC_STATIC, 0, cf.getName(),
1, UNMARSHALCONTEXT_CLASS);
}
/**
* Add exception handler code. The implementation of this abstract base
* class method provides handling specific to an unmarshalling method.
*
* @return handle for first instruction in handler
*/
public InstructionHandle genExceptionHandler() {
// first part of instruction sequence is create new exception object,
// duplicate two down (below caught exception), swap (so order is new,
// new, caught)
initStackState(new String[] {"java.lang.Exception"});
InstructionHandle start =
internalAppendCreateNew(FRAMEWORK_EXCEPTION_CLASS);
appendDUP_X1();
appendSWAP();
// second part of sequence is build StringBuffer, duplicate, load lead
// String, call constructor with String argument, load unmarshalling
// context, call position String method, call StringBuffer append,
// call StringBuffer toString
appendCreateNew("java.lang.StringBuffer");
appendDUP();
appendLoadConstant(UNMARSHAL_EXCEPTION_TEXT);
appendCallInit("java.lang.StringBuffer", "(Ljava/lang/String;)V");
loadContext();
appendCallVirtual(UNMARSHALLING_POSITION_METHOD,
UNMARSHALLING_POSITION_SIGNATURE);
appendCallVirtual("java.lang.StringBuffer.append",
"(Ljava/lang/String;)Ljava/lang/StringBuffer;");
appendCallVirtual("java.lang.StringBuffer.toString",
"()Ljava/lang/String;");
// final part of sequence is swap to get arguments in correct order,
// invoke exception constructor, throw exception
appendSWAP();
appendCallInit(FRAMEWORK_EXCEPTION_CLASS,
EXCEPTION_CONSTRUCTOR_SIGNATURE2);
appendThrow();
return start;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/MungedClass.java 0000644 0001750 0001750 00000040735 11175704054 026003 0 ustar twerner twerner /*
Copyright (c) 2003-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.classes;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import org.apache.bcel.Constants;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.JiBXException;
/**
* Modifiable class handler. Each instance controls changes to a particular
* class modified by one or more binding definitions. As methods are generated
* they're checked for uniqueness. If an already-generated method is found with
* the same characteristics (including byte code) as the one being generated,
* the already-generated is used instead.
*
* @author Dennis M. Sosnoski
*/
public class MungedClass
{
//
// Constants and such related to code generation.
/** Empty class file array. */
private static final ClassFile[] EMPTY_CLASSFILE_ARRAY = {};
/** Name and signature for generated methods without standard prefix. */
private static final String[] EXTRA_METHODS_MATCHES =
{
"marshal", "(Lorg/jibx/runtime/IMarshallingContext;)V",
"unmarshal", "(Lorg/jibx/runtime/IUnmarshallingContext;)V"
};
//
// Static data.
/** Munged class information. */
private static ArrayList s_classes;
/** Set of class names in list (used to assure uniqueness). */
private static HashSet s_classNameSet;
/** Map from generated class to binding information. */
private static HashMap s_classMap;
/** Map of directories already checked for JiBX classes. */
private static HashMap s_directories;
/** Map from class name to binding information. */
private static HashMap s_nameMap;
/** Munged classes to be unique-added at end of binding. */
private static ArrayList s_pendingClasses;
/** Munged class file information. */
private ClassFile m_classFile;
/** Map from method byte code and signature to method item. */
private HashMap m_methodMap;
/** Existing binding methods in class. */
private ExistingMethod[] m_existingMethods;
/** List of factory names for this class. */
private String m_factoryList;
/**
* Constructor. This sets up for modifying a class with added methods.
*
* @param cf owning class file information
*/
private MungedClass(ClassFile cf) {
// initialize basic class information
m_classFile = cf;
m_methodMap = new HashMap();
// get information for existing binding methods in this class
String[] extras = EXTRA_METHODS_MATCHES;
if (cf.isSuperclass("java.lang.Enum")) {
// enum class, add the serialize/deserialize methods to patterns
String[] copy = extras;
int length = copy.length;
extras = new String[length+4];
System.arraycopy(copy, 0, extras, 0, length);
extras[length++] = "_jibx_serialize";
extras[length++] = "(" + cf.getSignature() + ")Ljava/lang/String;";
extras[length++] = "_jibx_deserialize";
extras[length] = "(Ljava/lang/String;)" + cf.getSignature();
}
ExistingMethod[] exists = cf.getBindingMethods
(BindingDirectory.GENERATE_PREFIX, extras);
if (exists != null) {
for (int i = 0; i < exists.length; i++) {
m_methodMap.put(exists[i], exists[i]);
}
}
m_existingMethods = exists;
}
/**
* Get munged class file information.
*
* @return class file information for bound class
*/
/*package*/ ClassFile getClassFile() {
return m_classFile;
}
/**
* Delete pre-existing binding methods that are no longer needed.
*/
private void purgeUnusedMethods() {
if (m_existingMethods != null) {
for (int i = 0; i < m_existingMethods.length; i++) {
ExistingMethod method = m_existingMethods[i];
if (!method.isUsed()) {
method.delete();
}
}
}
}
/**
* Get unique method. If a method matching the byte code of the supplied
* method has already been defined the existing method is returned.
* Otherwise the method is added to the definitions. If necessary, a number
* suffix is appended to the method name to prevent conflicts with existing
* names.
*
* @param builder method to be defined
* @param suffix append name suffix to assure uniqueness flag
* @return defined method item
*/
/*package*/ BindingMethod getUniqueMethod(MethodBuilder builder,
boolean suffix) {
// try to find already added method with same characteristics
if (builder.getClassFile() != m_classFile) {
throw new IllegalStateException
("Internal error: wrong class for call");
}
builder.codeComplete(suffix);
BindingMethod method = (BindingMethod)m_methodMap.get(builder);
if (method == null) {
// System.out.println("No match found for method " +
// builder.getClassFile().getName()+ '.' + builder.getName() +
// "; adding method");
// create as new method
builder.addMethod();
m_methodMap.put(builder, builder);
return builder;
} else if (method instanceof ExistingMethod) {
((ExistingMethod)method).setUsed();
}
// System.out.println("Found " + method.getClassFile().getName()+
// '.' + method.getName() + " as match for " + builder.getName());
return method;
}
/**
* Get unique generated support class. Allows tracking of all generated
* classes for common handling with the bound classes. Each generated
* support class is associated with a particular bound class.
*
* @param cf generated class file
* @return unique class file information
*/
public static ClassFile getUniqueSupportClass(ClassFile cf) {
cf.codeComplete();
Object value = s_classMap.get(cf);
if (value == null) {
if (!s_classNameSet.contains(cf.getName())) {
s_classes.add(cf);
s_classNameSet.add(cf.getName());
}
s_classMap.put(cf, cf);
return cf;
} else {
ClassFile prior = (ClassFile)value;
prior.incrementUseCount();
return prior;
}
}
/**
* Check directory for JiBX generated files. Scans through all class files
* in the target directory and loads any that start with the JiBX
* identifier string which have not been added to the preserve list.
*
* @param root class path root for directory
* @param pack package relative to root directory
* @throws JiBXException on configuration error
*/
/*package*/ static void checkDirectory(File root, String pack)
throws JiBXException {
try {
File directory = new File
(root, pack.replace('.', File.separatorChar));
String cpath = directory.getCanonicalPath();
if (s_directories.get(cpath) == null) {
File[] matches = new File(cpath).listFiles(new JiBXFilter());
for (int i = 0; i < matches.length; i++) {
File file = matches[i];
String name = file.getName();
int split = name.indexOf('.');
if (split >= 0) {
name = name.substring(0, split);
}
if (pack.length() > 0) {
name = pack + '.' + name;
}
if (!ClassCache.isPreserveClass(name)) {
ClassFile cf = ClassCache.requireClassFile(name);
s_classes.add(cf);
s_classMap.put(cf, cf);
}
}
s_directories.put(cpath, cpath);
}
} catch (IOException ex) {
throw new JiBXException("Error loading class file", ex);
}
}
/**
* Add binding factory to class. The binding factories are accumulated as
* a delimited string during generation, then dumped to a static field in
* the class at the end.
*
* @param fact binding factory name
*/
/*package*/ void addFactory(String fact) {
String match = "|" + fact + "|";
if (m_factoryList == null) {
m_factoryList = match;
} else if (m_factoryList.indexOf(match) < 0) {
m_factoryList = m_factoryList + fact + "|";
}
}
/**
* Generate factory list. Adds or replaces the existing static array of
* factories in the class.
*/
/*package*/ void setFactoryList() {
if (m_factoryList != null) {
short access = Constants.ACC_PUBLIC | Constants.ACC_FINAL |
Constants.ACC_STATIC;
m_classFile.updateField("java.lang.String",
BindingDirectory.BINDINGLIST_NAME, access, m_factoryList);
}
}
/**
* Get modification tracking information for class.
*
* @param cf information for class to be modified (must be writable)
* @return binding information for class
* @throws JiBXException on configuration error
*/
/*package*/ static MungedClass getInstance(ClassFile cf)
throws JiBXException {
String name = cf.getName();
MungedClass inst = (MungedClass)s_nameMap.get(name);
if (inst == null) {
if (ClassCache.isPreserveClass(name)) {
throw new IllegalStateException("Internal error - attempt to modify class in preserve set");
}
inst = new MungedClass(cf);
s_nameMap.put(name, inst);
if (cf.isComplete()) {
if (s_classMap.get(cf) == null) {
if (!s_classNameSet.contains(name)) {
s_classes.add(inst);
s_classNameSet.add(name);
}
s_classMap.put(cf, cf);
} else {
throw new IllegalStateException
("Existing class conflicts with load");
}
String pack = cf.getPackage();
checkDirectory(cf.getRoot(), pack);
}
}
inst.m_classFile.incrementUseCount();
return inst;
}
/**
* Add unique support class at end of binding process. This allows a class
* to be constructed in steps during handling of one or more bindings, with
* the class finished and checked for uniqueness only after all bindings
* have been handled. The actual add of the class is done during the
* {@link #fixDispositions()} handling.
*
* @param cf class file to be added as unique support class at end of
* binding
*/
public static void delayedAddUnique(ClassFile cf) {
s_pendingClasses.add(cf);
}
/**
* Add class file to set modified. This uses the class name as a identifier
* to prevent duplicate entries in the list, so that classes which are still
* under construction can be handled.
*
* @param cf
*/
public static void addModifiedClass(ClassFile cf) {
String name = cf.getName();
if (!s_classNameSet.contains(name)) {
if (ClassCache.isPreserveClass(name)) {
throw new IllegalStateException("Internal error - attempt to modify class in preserve set");
} else {
s_classes.add(cf);
s_classNameSet.add(name);
}
}
}
/**
* Finalize class name assignments and dispositions.
*
* @return three-way array of class files, for modified, unchanged, and
* deleted
*/
public static ClassFile[][] fixDispositions() {
// process all pending class adds
for (int i = 0; i < s_pendingClasses.size(); i++) {
getUniqueSupportClass((ClassFile)s_pendingClasses.get(i));
}
// finalize and categorize classes
ArrayList writes = new ArrayList();
ArrayList keeps = new ArrayList();
ArrayList deletes = new ArrayList();
for (int i = 0; i < s_classes.size(); i++) {
Object obj = s_classes.get(i);
ClassFile cf;
if (obj instanceof MungedClass) {
MungedClass inst = (MungedClass)obj;
inst.purgeUnusedMethods();
inst.setFactoryList();
cf = inst.getClassFile();
} else {
cf = (ClassFile)obj;
}
if (cf.isModified()) {
writes.add(cf);
} else if (cf.getUseCount() > 0 || ClassCache.isPreserveClass(cf.getName())) {
keeps.add(cf);
} else {
deletes.add(cf);
}
}
// return changes in separate lists
ClassFile[][] results = new ClassFile[3][];
results[0] = (ClassFile[])writes.toArray(EMPTY_CLASSFILE_ARRAY);
results[1] = (ClassFile[])keeps.toArray(EMPTY_CLASSFILE_ARRAY);
results[2] = (ClassFile[])deletes.toArray(EMPTY_CLASSFILE_ARRAY);
return results;
}
/**
* Write all modified class files, and delete all obsolete class files from
* previous runs of the binding compiler.
*
* @throws JiBXException on write error
*/
public static void writeChanges() throws JiBXException {
try {
// write all modifications and delete unused old files
for (int i = 0; i < s_classes.size(); i++) {
Object obj = s_classes.get(i);
ClassFile cf;
if (obj instanceof MungedClass) {
MungedClass inst = (MungedClass)obj;
cf = inst.getClassFile();
} else {
cf = (ClassFile)obj;
}
if (cf.isModified()) {
cf.writeFile();
} else if (cf.getUseCount() == 0 && !ClassCache.isPreserveClass(cf.getName())) {
cf.delete();
}
}
} catch (IOException ex) {
throw new JiBXException("Error writing to file", ex);
}
}
/**
* Discard cached information and reset in preparation for a new binding
* run.
*/
public static void reset() {
s_classes = new ArrayList();
s_classNameSet = new HashSet();
s_classMap = new HashMap();
s_directories = new HashMap();
s_nameMap = new HashMap();
s_pendingClasses = new ArrayList();
}
/**
* Filter for class files generated by JiBX.
*/
private static class JiBXFilter implements FileFilter
{
public boolean accept(File file) {
String name = file.getName();
return name.startsWith(BindingDirectory.GENERATE_PREFIX) &&
name.endsWith(".class");
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/ClassItem.java 0000644 0001750 0001750 00000050127 11320454026 025447 0 ustar twerner twerner /*
Copyright (c) 2003-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.classes;
import java.util.HashMap;
import org.apache.bcel.Constants;
import org.apache.bcel.classfile.Attribute;
import org.apache.bcel.classfile.ExceptionTable;
import org.apache.bcel.classfile.FieldOrMethod;
import org.apache.bcel.classfile.LocalVariable;
import org.apache.bcel.classfile.LocalVariableTable;
import org.apache.bcel.classfile.Method;
import org.apache.bcel.classfile.Utility;
import org.apache.bcel.generic.ArrayType;
import org.apache.bcel.generic.ObjectType;
import org.apache.bcel.generic.Type;
import org.jibx.runtime.JiBXException;
/**
* Wrapper for field or method information. Provides the information needed
* for access to either existing or added methods in existing classes.
*
* @author Dennis M. Sosnoski
*/
public class ClassItem
{
/** Tag value for signature attribute. */
private static final byte SIGNATURE_ATTRIBUTE_TAG = 10;
/** Map for primitive type signature variants. */
private static HashMap s_primitiveMap = new HashMap();
/** Map from type name to BCEL type. */
private static HashMap s_typeMap = new HashMap();
/** Map from method signature to array of argument types. */
private static HashMap s_signatureParamsMap = new HashMap();
/** Map from method signature to return type. */
private static HashMap s_signatureTypeMap = new HashMap();
static {
s_primitiveMap.put("boolean", new String[] { "Z", "I" });
s_primitiveMap.put("byte", new String[] { "B", "S", "I" });
s_primitiveMap.put("char", new String[] { "C", "I" });
s_primitiveMap.put("double", new String[] { "D" });
s_primitiveMap.put("float", new String[] { "F" });
s_primitiveMap.put("int", new String[] { "I" });
s_primitiveMap.put("long", new String[] { "J" });
s_primitiveMap.put("short", new String[] { "S", "I" });
s_primitiveMap.put("void", new String[] { "V" });
s_typeMap.put("boolean", Type.BOOLEAN);
s_typeMap.put("byte", Type.BYTE);
s_typeMap.put("char", Type.CHAR);
s_typeMap.put("double", Type.DOUBLE);
s_typeMap.put("float", Type.FLOAT);
s_typeMap.put("int", Type.INT);
s_typeMap.put("long", Type.LONG);
s_typeMap.put("short", Type.SHORT);
s_typeMap.put("void", Type.VOID);
}
/** Owning class information. */
private ClassFile m_classFile;
/** Item name. */
private String m_name;
/** Encoded signature. */
private String m_signature;
/** Fully qualified class name of item type. */
private String m_typeName;
/** Argument types for method. */
private String[] m_argTypes;
/** Parameter names for method (null if not yet found). */
private String[] m_parmNames;
/** Wrapped existing item. */
private FieldOrMethod m_item;
/**
* Constructor. Builds a wrapper for an item based on an existing field or
* method.
*
* @param name field or method name
* @param cf owning class information
* @param item field or method information
*/
public ClassItem(String name, ClassFile cf, FieldOrMethod item) {
m_classFile = cf;
m_name = name;
m_item = item;
String signature = item.getSignature();
if (signature.startsWith("+")) {
// ignore leading '+' used by BCEL for generic signature information
signature = signature.substring(1);
}
m_signature = signature;
if (item instanceof Method) {
m_typeName = getTypeFromSignature(signature);
m_argTypes = getParametersFromSignature(signature);
} else {
m_typeName = Utility.signatureToString(signature, false);
}
}
/**
* Get owning class information.
*
* @return owning class information
*/
public ClassFile getClassFile() {
return m_classFile;
}
/**
* Get item name.
*
* @return item name
*/
public String getName() {
return m_name;
}
/**
* Get fully-qualified class and method name.
*
* @return fully-qualified class and method name
*/
public String getFullName() {
return m_classFile.getName() + '.' + m_name;
}
/**
* Get item type as fully qualified class name.
*
* @return item type name
*/
public String getTypeName() {
return m_typeName;
}
/**
* Get number of arguments for method.
*
* @return argument count for method, or zero if not a method
*/
public int getArgumentCount() {
if (m_item instanceof Method) {
return m_argTypes.length;
} else {
return 0;
}
}
/**
* Get argument type as fully qualified class name.
*
* @param index argument number
* @return argument type name
*/
public String getArgumentType(int index) {
if (m_item instanceof Method) {
return m_argTypes[index];
} else {
throw new IllegalArgumentException("Internal error: not a method");
}
}
/**
* Get method parameter name.
*
* @param index parameter index
* @return parameter name
*/
public String getParameterName(int index) {
if (m_item instanceof Method) {
if (m_parmNames == null) {
int offset = isStatic() ? 0 : 1;
LocalVariableTable vtab =
((Method)m_item).getLocalVariableTable();
String[] names = new String[m_argTypes.length];
int fill = 0;
while (fill < names.length) {
LocalVariable var = vtab.getLocalVariable(offset);
offset++;
String type = m_argTypes[fill];
if ("long".equals(type) || "double".equals(type)) {
offset++;
}
names[fill++] = var.getName();
}
m_parmNames = names;
}
return m_parmNames[index];
} else {
throw new IllegalArgumentException("Internal error: not a method");
}
}
/**
* Get argument types as array of fully qualified class names.
*
* @return array of argument types
*/
public String[] getArgumentTypes() {
if (m_item instanceof Method) {
return m_argTypes;
} else {
return null;
}
}
/**
* Get access flags.
*
* @return flags for access type of field or method
*/
public int getAccessFlags() {
return m_item.getAccessFlags();
}
/**
* Set access flags.
*
* @param flags access flags for field or method
*/
public void setAccessFlags(int flags) {
m_item.setAccessFlags(flags);
m_classFile.setModified();
}
/**
* Make accessible item. Check if this field or method is accessible from
* another class, and if not decreases the access restrictions to make it
* accessible.
*
* @param src class file for required access
*/
public void makeAccessible(ClassFile src) {
// no need to change if already public access
int access = getAccessFlags();
if ((access & Constants.ACC_PUBLIC) == 0) {
// check for same package as most restrictive case
ClassFile dest = getClassFile();
if (dest.getPackage().equals(src.getPackage())) {
if ((access & Constants.ACC_PRIVATE) != 0) {
access = access - Constants.ACC_PRIVATE;
}
} else {
// check if access is from a subclass of this method class
ClassFile ancestor = src;
while ((ancestor = ancestor.getSuperFile()) != null) {
if (ancestor == dest) {
break;
}
}
// handle access adjustments based on subclass status
if (ancestor == null) {
int clear = Constants.ACC_PRIVATE |
Constants.ACC_PROTECTED;
access = (access & ~clear) | Constants.ACC_PUBLIC;
} else if ((access & Constants.ACC_PROTECTED) == 0) {
access = (access & ~Constants.ACC_PRIVATE) |
Constants.ACC_PROTECTED;
}
}
// set new access flags
if (access != getAccessFlags()) {
if (dest.isModifiable()) {
setAccessFlags(access);
} else {
throw new IllegalStateException("Internal error - unable to change access permissions");
}
}
}
}
/**
* Check if item is a static.
*
* @return true if a static, false if member
*/
public boolean isStatic() {
return (getAccessFlags() & Constants.ACC_STATIC) != 0;
}
/**
* Get method signature.
*
* @return encoded method signature
*/
public String getSignature() {
return m_signature;
}
/**
* Check if item is a method.
*
* @return true if a method, false if a field
*/
public boolean isMethod() {
return m_item == null || m_item instanceof Method;
}
/**
* Check if item is an initializer.
*
* @return true if an initializer, false if a
* field or normal method
*/
public boolean isInitializer() {
return m_item != null && m_item.getName().equals("");
}
/**
* Get names of exceptions thrown by method.
*
* @return array of exceptions thrown by method, or null if
* a field
*/
public String[] getExceptions() {
if (m_item instanceof Method) {
ExceptionTable etab = ((Method)m_item).getExceptionTable();
if (etab != null) {
return etab.getExceptionNames();
} else {
return org.jibx.runtime.Utility.EMPTY_STRING_ARRAY;
}
}
return null;
}
/**
* Get the generics signature information for item.
*
* @return generics signature (null if none)
*/
public String getGenericsSignature() {
Attribute[] attrs = m_item.getAttributes();
for (int j = 0; j < attrs.length; j++) {
Attribute attr = attrs[j];
if (attr.getTag() == SIGNATURE_ATTRIBUTE_TAG) {
return attr.toString();
}
}
return null;
}
/**
* Check if type is a primitive.
*
* @param type
* @return true if a primitive, false if not
*/
public static boolean isPrimitive(String type) {
return s_primitiveMap.get(type) != null;
}
/**
* Get the signature for a primitive.
*
* @param type
* @return signature for a primitive type
*/
public static String getPrimitiveSignature(String type) {
return ((String[])s_primitiveMap.get(type))[0];
}
/**
* Get parameter type names from method signature.
*
* @param sig method signature to be decoded
* @return array of argument type names
*/
public static String[] getParametersFromSignature(String sig) {
String[] types = (String[])s_signatureParamsMap.get(sig);
if (types == null) {
types = Utility.methodSignatureArgumentTypes(sig, false);
s_signatureParamsMap.put(sig, types);
}
return types;
}
/**
* Get return type names from method signature.
*
* @param sig method signature to be decoded
* @return return type name
*/
public static String getTypeFromSignature(String sig) {
String type = (String)s_signatureTypeMap.get(sig);
if (type == null) {
type = Utility.methodSignatureReturnType(sig, false);
s_signatureTypeMap.put(sig, type);
}
return type;
}
/**
* Create type from name.
*
* @param name fully qualified type name
* @return corresponding type
*/
public static Type typeFromName(String name) {
// first check for type already created
Type type = (Type)s_typeMap.get(name);
if (type == null) {
// new type, strip off array dimensions
int dimen = 0;
String base = name;
while (base.endsWith("[]")) {
dimen++;
base = base.substring(0, base.length()-2);
}
// check for base type defined if array
if (dimen > 0) {
type = (Type)s_typeMap.get(base);
}
// create and record base type if new
if (type == null) {
type = new ObjectType(base);
s_typeMap.put(base, type);
}
// create and record array type
if (dimen > 0) {
type = new ArrayType(type, dimen);
s_typeMap.put(name, type);
}
}
return type;
}
/**
* Get virtual method by fully qualified name. This splits the class
* name from the method name, finds the class, and then tries to find a
* matching method name in that class or a superclass.
*
* @param name fully qualified class and method name
* @param sigs possible method signatures
* @return information for the method, or null if not found
* @throws JiBXException if configuration error
*/
public static ClassItem findVirtualMethod(String name, String[] sigs)
throws JiBXException {
// get the class containing the method
int split = name.lastIndexOf('.');
if (split < 0) {
throw new IllegalArgumentException("Internal error - not a qualified class and method name: " + name);
}
String cname = name.substring(0, split);
String mname = name.substring(split+1);
ClassFile cf = ClassCache.requireClassFile(cname);
// find the method in class or superclass
for (int i = 0; i < sigs.length; i++) {
ClassItem method = cf.getMethod(mname, sigs[i]);
if (method != null) {
return method;
}
}
return null;
}
/**
* Get static method by fully qualified name. This splits the class
* name from the method name, finds the class, and then tries to find a
* matching method name in that class.
*
* @param name fully qualified class and method name
* @param sigs possible method signatures
* @return information for the method, or null if not found
* @throws JiBXException if configuration error
*/
public static ClassItem findStaticMethod(String name, String[] sigs)
throws JiBXException {
// get the class containing the method
int split = name.lastIndexOf('.');
if (split < 0) {
throw new IllegalArgumentException("Internal error - not a qualified class and method name: " + name);
}
String cname = name.substring(0, split);
String mname = name.substring(split+1);
ClassFile cf = ClassCache.requireClassFile(cname);
// find the method in class or superclass
for (int i = 0; i < sigs.length; i++) {
ClassItem method = cf.getStaticMethod(mname, sigs[i]);
if (method != null) {
return method;
}
}
return null;
}
/**
* Get all variant signatures for a fully qualified class name. The
* returned array gives all signatures (for interfaces or classes) which
* instances of the class can match.
*
* @param name fully qualified class name
* @return possible signature variations for instances of the class
* @throws JiBXException if configuration error
*/
public static String[] getSignatureVariants(String name)
throws JiBXException {
Object obj = s_primitiveMap.get(name);
if (obj == null) {
ClassFile cf = ClassCache.requireClassFile(name);
return cf.getInstanceSigs();
} else {
return (String[])obj;
}
}
/**
* Check if a value of one type can be directly assigned to another type.
* This is basically the equivalent of the instanceof operator, but with
* application to primitive types as well as object types.
*
* @param from fully qualified class name of initial type
* @param to fully qualified class name of assignment type
* @return true if assignable, false if not
* @throws JiBXException if configuration error
*/
public static boolean isAssignable(String from, String to)
throws JiBXException {
// always assignable if the two are the same
if (from.equals(to)) {
return true;
} else {
// try direct lookup for primitive types
Object fobj = s_primitiveMap.get(from);
Object tobj = s_primitiveMap.get(to);
if (fobj == null && tobj == null) {
// assignable if from type has to as a possible signature
ClassFile cf = ClassCache.requireClassFile(from);
String[] sigs = cf.getInstanceSigs();
String match = Utility.getSignature(to);
for (int i = 0; i < sigs.length; i++) {
if (match.equals(sigs[i])) {
return true;
}
}
return false;
} else if (fobj != null && tobj != null) {
// assignable if from type has to as a possible signature
String[] fsigs = (String[])fobj;
String[] tsigs = (String[])tobj;
if (tsigs.length == 1) {
for (int i = 0; i < fsigs.length; i++) {
if (fsigs[i] == tsigs[0]) {
return true;
}
}
}
return false;
} else {
// primitive and object types never assignable
return false;
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/BranchTarget.java 0000644 0001750 0001750 00000006434 10071714136 026134 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.classes;
import org.apache.bcel.generic.InstructionHandle;
/**
* Wrapper for branch target information. This preserves a snapshot of the stack
* state for the branch target, allowing it to be matched against the stack
* state for the branch source.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class BranchTarget
{
/** Actual wrapped instruction handle. */
private final InstructionHandle m_targetHandle;
/** Stack state for branch target. */
private final String[] m_stackTypes;
/**
* Constructor.
*
* @param hand instruction handle
* @param types array of types of values on stack
*/
/*package*/ BranchTarget(InstructionHandle hand, String[] types) {
m_targetHandle = hand;
m_stackTypes = types;
}
/**
* Get actual target instruction.
*
* @return handle for target instruction
*/
/*package*/ InstructionHandle getInstruction() {
return m_targetHandle;
}
/**
* Get stack state information.
*
* @return array of type names on stack
*/
/*package*/ String[] getStack() {
return m_stackTypes;
}
/**
* Matches the branch target stack state against the supplied stack state.
*
* @param types array of types of values on stack
* @return true if stack states match, false if
* not
*/
/*package*/ boolean matchStacks(String[] types) {
// match stack states
if (types.length == m_stackTypes.length) {
for (int i = 0; i < types.length; i++) {
if (!types[i].equals(m_stackTypes[i])) {
return false;
}
}
return true;
} else {
return false;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/MarshalBuilder.java 0000644 0001750 0001750 00000007677 11072341342 026475 0 ustar twerner twerner /*
Copyright (c) 2003-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.classes;
import org.apache.bcel.Constants;
import org.apache.bcel.generic.InstructionHandle;
import org.apache.bcel.generic.ObjectType;
import org.apache.bcel.generic.Type;
/**
* Marshalling method builder. Tracks the creation of a marshalling method,
* including special handling of exceptions that may be generated by object
* accesses during the marshalling process.
*
* @author Dennis M. Sosnoski
*/
public class MarshalBuilder extends MarshalUnmarshalBuilder
{
//
// Constants for code generation.
private static final String MARSHALCONTEXT_CLASS =
"org.jibx.runtime.impl.MarshallingContext";
protected static final String MARSHAL_EXCEPTION_TEXT =
"Error while marshalling";
private static final Type MARSHALCONTEXT_TYPE =
new ObjectType(MARSHALCONTEXT_CLASS);
/**
* Constructor. This sets up for constructing a marshalling method with
* public access and wrapped exception handling. If the method is being
* generated directly to the class being marshalled it's built as a virtual
* method; otherwise, it's done as a static method.
*
* @param name method name to be built
* @param cf owning class file information
* @param mf method generation class file information
*/
public MarshalBuilder(String name, ClassFile cf, ClassFile mf) {
super(name, Type.VOID, new Type[] {cf.getType(), MARSHALCONTEXT_TYPE},
mf, Constants.ACC_PUBLIC | Constants.ACC_STATIC, 0, cf.getName(),
1, MARSHALCONTEXT_CLASS);
}
/**
* Add exception handler code. The implementation of this abstract base
* class method provides handling specific to a marshalling method.
*
* @return handle for first instruction in handler
*/
public InstructionHandle genExceptionHandler() {
// instruction sequence is create new exception object, duplicate two
// down (below caught exception), swap (so order is new, new, caught),
// load message, swap again, invoke constructor, and throw exception
initStackState(new String[] {"java.lang.Exception"});
InstructionHandle start =
internalAppendCreateNew(FRAMEWORK_EXCEPTION_CLASS);
appendDUP_X1();
appendSWAP();
appendLoadConstant(MARSHAL_EXCEPTION_TEXT);
appendSWAP();
appendCallInit(FRAMEWORK_EXCEPTION_CLASS,
EXCEPTION_CONSTRUCTOR_SIGNATURE2);
appendThrow();
return start;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/MethodBuilder.java 0000644 0001750 0001750 00000165261 11256241372 026326 0 ustar twerner twerner /*
Copyright (c) 2003-2008, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.classes;
import java.util.ArrayList;
import java.util.HashMap;
import org.apache.bcel.Constants;
import org.apache.bcel.classfile.Method;
import org.apache.bcel.classfile.Utility;
import org.apache.bcel.generic.ANEWARRAY;
import org.apache.bcel.generic.BranchHandle;
import org.apache.bcel.generic.CompoundInstruction;
import org.apache.bcel.generic.GOTO;
import org.apache.bcel.generic.IFEQ;
import org.apache.bcel.generic.IFGE;
import org.apache.bcel.generic.IFLT;
import org.apache.bcel.generic.IFNE;
import org.apache.bcel.generic.IFNONNULL;
import org.apache.bcel.generic.IFNULL;
import org.apache.bcel.generic.IF_ICMPNE;
import org.apache.bcel.generic.IINC;
import org.apache.bcel.generic.Instruction;
import org.apache.bcel.generic.InstructionConstants;
import org.apache.bcel.generic.InstructionFactory;
import org.apache.bcel.generic.InstructionHandle;
import org.apache.bcel.generic.InstructionList;
import org.apache.bcel.generic.LocalVariableGen;
import org.apache.bcel.generic.MULTIANEWARRAY;
import org.apache.bcel.generic.MethodGen;
import org.apache.bcel.generic.NEWARRAY;
import org.apache.bcel.generic.ReferenceType;
import org.apache.bcel.generic.Type;
import org.jibx.runtime.JiBXException;
import org.jibx.util.StringStack;
/**
* Method builder. Organizes and tracks the creation of a method, providing
* convenience methods for common operations. This is customized for the needs
* of JiBX, with some predetermined settings as appropriate. It supplies hash
* code and equality checking based on the method signature and actual byte
* code of the generated method, ignoring the method name.
*
* @author Dennis M. Sosnoski
*/
public abstract class MethodBuilder extends BindingMethod
{
//
// Constants for code generation.
public static final String FRAMEWORK_EXCEPTION_CLASS =
"org.jibx.runtime.JiBXException";
public static final String EXCEPTION_CONSTRUCTOR_SIGNATURE1 =
"(Ljava/lang/String;)V";
public static final String EXCEPTION_CONSTRUCTOR_SIGNATURE2 =
"(Ljava/lang/String;Ljava/lang/Throwable;)V";
public static final int SYNTHETIC_ACCESS_FLAG = 0x1000;
//
// Static data.
/** Table of argument name lists (generated as needed). */
protected static ArrayList s_argNameLists = new ArrayList();
//
// Actual instance data
/** Builder for class instructions. */
protected InstructionBuilder m_instructionBuilder;
/** List of instructions in method definition. */
private InstructionList m_instructionList;
/** List of types currently on stack. */
private StringStack m_stackState;
/** Generator for constructing method. */
protected MethodGen m_generator;
/** Actual generated method information. */
protected Method m_method;
/** Method class item information. */
protected ClassItem m_item;
/** Value types associated with local variable slots. */
private ArrayList m_localTypes;
/** Exceptions needing to be handled in method (lazy create,
null if not used). */
protected ArrayList m_exceptions;
/** Accumulated hash code from adding instructions. */
protected int m_hashCode;
/** Branch to be aimed at next appended instruction. */
protected BranchWrapper[] m_targetBranches;
/** Map for initialized properties (lazy create, null if not
used). */
protected HashMap m_valueMap;
/**
* Constructor. This sets up for constructing a method with public access.
*
* @param name method name to be built
* @param ret method return type
* @param args types of arguments
* @param cf owning class file information
* @param access flags for method access
*/
protected MethodBuilder(String name, Type ret, Type[] args,
ClassFile cf, int access) {
super(cf);
// make sure the dummy argument names are defined
if (args.length >= s_argNameLists.size()) {
// append to end of argument names list
for (int i = s_argNameLists.size(); i <= args.length; i++) {
String[] list = new String[i];
if (i > 0) {
Object last = s_argNameLists.get(i-1);
System.arraycopy(last, 0, list, 0, i-1);
list[i-1] = "arg" + i;
}
s_argNameLists.add(list);
}
}
// create the method generator with empty instruction list
String[] names = (String[])s_argNameLists.get(args.length);
m_instructionList = new InstructionList();
m_stackState = new StringStack();
m_instructionBuilder = cf.getInstructionBuilder();
m_generator = new MethodGen(access | SYNTHETIC_ACCESS_FLAG, ret, args,
names, name, cf.getName(), m_instructionList, cf.getConstPoolGen());
// initialize local variables for method parameters
m_localTypes = new ArrayList();
if ((access & Constants.ACC_STATIC) == 0) {
m_localTypes.add(cf.getName());
}
for (int i = 0; i < args.length; i++) {
m_localTypes.add(args[i].toString());
if (args[i].getSize() > 1) {
m_localTypes.add(null);
}
}
}
/**
* Get name of method being constructed.
*
* @return name of method being constructed
*/
public String getName() {
return m_generator.getName();
}
/**
* Get signature.
*
* @return signature for method
*/
public String getSignature() {
return m_generator.getSignature();
}
/**
* Get access flags.
*
* @return flags for access type of method
*/
public int getAccessFlags() {
return m_generator.getAccessFlags();
}
/**
* Set access flags.
*
* @param flags access type to be set
*/
public void setAccessFlags(int flags) {
m_generator.setAccessFlags(flags);
}
/**
* Get the actual method. This can only be called once code generation is
* completed (after the {@link #codeComplete(boolean)} method is called).
*
* @return constructed method information
*/
public Method getMethod() {
if (m_method == null) {
throw new IllegalStateException("Method still under construction");
} else {
return m_method;
}
}
/**
* Add keyed value to method definition.
*
* @param key retrieval key
* @param value keyed value
* @return prior value for key
*/
public Object setKeyValue(Object key, Object value) {
if (m_valueMap == null) {
m_valueMap = new HashMap();
}
return m_valueMap.put(key, value);
}
/**
* Get local variable for object.
*
* @param key object key for local variable
* @return local variable
*/
public Object getKeyValue(Object key) {
return m_valueMap == null ? null : m_valueMap.get(key);
}
/**
* Add exception to those needing handling.
*
* @param name fully qualified name of exception class
*/
public void addException(String name) {
if (m_exceptions == null) {
m_exceptions = new ArrayList();
}
if (!m_exceptions.contains(name)) {
m_exceptions.add(name);
}
}
/**
* Add exceptions thrown by called method to those needing handling.
*
* @param method information for method to be handled
*/
public void addMethodExceptions(ClassItem method) {
String[] excepts = method.getExceptions();
if (excepts != null) {
for (int i = 0; i < excepts.length; i++) {
addException(excepts[i]);
}
}
}
/**
* Get first instruction in method.
*
* @return handle for first instruction in method
*/
protected InstructionHandle getFirstInstruction() {
return m_instructionList.getStart();
}
/**
* Get last instruction in method.
*
* @return handle for last instruction in method
*/
protected InstructionHandle getLastInstruction() {
return m_instructionList.getEnd();
}
/**
* Target branches if pending. This implements setting the target of
* branch instructions supplied using the {@link #targetNext} method.
*
* @param inst handle for appended instruction
*/
protected final void setTarget(InstructionHandle inst) {
if (m_targetBranches != null) {
// TODO: fix this ugly kludge with code rewrite
// adjust stack with POPs if need to match size
String[] types = m_stackState.toArray();
if (m_targetBranches.length > 0) {
boolean match = true;
int depth = m_targetBranches[0].getStackState().length;
for (int i = 1; i < m_targetBranches.length; i++) {
if (depth != m_targetBranches[i].getStackState().length) {
match = false;
break;
}
}
if (match) {
if (depth > types.length) {
BranchWrapper merge = new BranchWrapper
(m_instructionList.insert(inst, new GOTO(null)),
types, this);
String[] stack = m_targetBranches[0].getStackState();
m_stackState = new StringStack(stack);
InstructionHandle poph = m_instructionList.
insert(inst, InstructionConstants.POP);
for (int i = 0; i < m_targetBranches.length; i++) {
m_targetBranches[i].setTarget(poph, stack, this);
}
m_stackState.pop();
while (m_stackState.size() > types.length) {
m_instructionList.insert(inst,
InstructionConstants.POP);
m_stackState.pop();
}
merge.setTarget(inst, m_stackState.toArray(), this);
m_targetBranches = null;
return;
} else {
while (depth < types.length) {
m_instructionList.insert(inst,
InstructionConstants.POP);
m_stackState.pop();
types = m_stackState.toArray();
}
}
}
}
// set all branch targets
for (int i = 0; i < m_targetBranches.length; i++) {
m_targetBranches[i].setTarget(inst, types, this);
}
m_targetBranches = null;
}
}
/**
* Generate description of current stack state.
*
* @return stack state description
*/
private String describeStack() {
StringBuffer buff = new StringBuffer();
String[] types = m_stackState.toArray();
for (int i = 0; i < types.length; i++) {
buff.append(" ");
buff.append(i);
buff.append(": ");
buff.append(types[i]);
buff.append('\n');
}
return buff.toString();
}
/**
* Verify that a pair of value types represent compatible types. This checks
* for equal types or downcast object types.
*
* @param type actual known type of value
* @param need type needed
*/
private void verifyCompatible(String type, String need) {
if (!need.equals(type)) {
try {
if ("".equals(type)) {
if (ClassItem.isPrimitive(need)) {
throw new IllegalStateException
("Internal error: Expected " + need +
" on stack , found null");
}
} else if ("java.lang.Object".equals(need)) {
if (ClassItem.isPrimitive(type)) {
throw new IllegalStateException("Internal error: " +
"Expected object reference on stack, found " +
type + "\n full stack:\n" + describeStack());
}
} else {
boolean match = false;
if ("int".equals(need)) {
match = "boolean".equals(type) ||
"short".equals(type) || "char".equals(type) ||
"byte".equals(type);
} else if ("int".equals(type)) {
match = "boolean".equals(need) ||
"short".equals(need) || "char".equals(need) ||
"byte".equals(need);
}
if (!match && !ClassItem.isAssignable(type, need)) {
throw new IllegalStateException
("Internal error: Expected " + need +
" on stack, found " + type + "\n full stack:\n" +
describeStack());
}
}
} catch (JiBXException e) {
throw new RuntimeException
("Internal error: Attempting to compare types " + need +
" and " + type);
}
}
}
/**
* Verify that at least the specified number of items are present on the
* stack.
*
* @param count minimum number of items required
*/
private void verifyStackDepth(int count) {
if (m_stackState.size() < count) {
throw new IllegalStateException
("Internal error: Too few values on stack\n full stack:\n" +
describeStack());
}
}
/**
* Verify the top value in the stack state resulting from the current
* instruction list.
*
* @param t1 expected type for top item on stack
*/
private void verifyStack(String t1) {
verifyStackDepth(1);
verifyCompatible(m_stackState.peek(), t1);
}
/**
* Verify the top value in the stack state resulting from the current
* instruction list is an array.
*
* @return array item type
*/
private String verifyArray() {
verifyStackDepth(1);
String type = m_stackState.peek();
if (type.endsWith("[]")) {
return type.substring(0, type.length()-2);
} else {
throw new IllegalStateException
("Internal error: Expected array type on stack , found " +
type);
}
}
/**
* Verify the top value in the stack state resulting from the current
* instruction list is an array of the specified type.
*
* @param type array item type
*/
private void verifyArray(String type) {
String atype = verifyArray();
if (!atype.equals(type)) {
throw new IllegalStateException
("Internal error: Expected array of " + type +
" on stack , found array of " + atype);
}
}
/**
* Verify the top two values in the stack state resulting from the current
* instruction list.
*
* @param t1 expected type for first item on stack
* @param t2 expected type for second item on stack
*/
private void verifyStack(String t1, String t2) {
verifyStackDepth(2);
verifyCompatible(m_stackState.peek(), t1);
verifyCompatible(m_stackState.peek(1), t2);
}
/**
* Verify the top values in the stack state resulting from the current
* instruction list. This form checks only the actual call parameters.
*
* @param types expected parameter types on stack
*/
private void verifyCallStack(String[] types) {
// make sure there are enough items on stack
int count = types.length;
verifyStackDepth(count);
// verify all parameter types for call
for (int i = 0; i < count; i++) {
int slot = count - i - 1;
verifyCompatible(m_stackState.peek(slot), types[i]);
}
}
/**
* Verify the top values in the stack state resulting from the current
* instruction list. This form checks both the object being called and the
* actual call parameters.
*
* @param clas name of method class
* @param types expected parameter types on stack
*/
private void verifyCallStack(String clas, String[] types) {
// start by verifying object reference
int count = types.length;
verifyStackDepth(count+1);
verifyCompatible(m_stackState.peek(count), clas);
// check values for call parameters
verifyCallStack(types);
}
/**
* Verify that the top value in the stack state resulting from the current
* instruction list is an object reference.
*/
private void verifyStackObject() {
verifyStackDepth(1);
String top = m_stackState.peek();
if (ClassItem.isPrimitive(top)) {
throw new IllegalStateException("Internal error: " +
"Expected object reference on stack , found " +
m_stackState.peek() + "\n full stack:\n" + describeStack());
}
}
/**
* Append IFEQ branch instruction to method.
*
* @param src object responsible for generating branch
* @return wrapper for appended conditional branch
*/
public BranchWrapper appendIFEQ(Object src) {
verifyStack("int");
BranchHandle hand = m_instructionList.append(new IFEQ(null));
setTarget(hand);
m_stackState.pop();
return new BranchWrapper(hand, m_stackState.toArray(), src);
}
/**
* Append IFGE branch instruction to method.
*
* @param src object responsible for generating branch
* @return wrapper for appended conditional branch
*/
public BranchWrapper appendIFGE(Object src) {
verifyStack("int");
BranchHandle hand = m_instructionList.append(new IFGE(null));
setTarget(hand);
m_stackState.pop();
return new BranchWrapper(hand, m_stackState.toArray(), src);
}
/**
* Append IFLT branch instruction to method.
*
* @param src object responsible for generating branch
* @return wrapper for appended conditional branch
*/
public BranchWrapper appendIFLT(Object src) {
verifyStack("int");
BranchHandle hand = m_instructionList.append(new IFLT(null));
setTarget(hand);
m_stackState.pop();
return new BranchWrapper(hand, m_stackState.toArray(), src);
}
/**
* Append IFNE branch instruction to method.
*
* @param src object responsible for generating branch
* @return wrapper for appended conditional branch
*/
public BranchWrapper appendIFNE(Object src) {
verifyStack("int");
BranchHandle hand = m_instructionList.append(new IFNE(null));
setTarget(hand);
m_stackState.pop();
return new BranchWrapper(hand, m_stackState.toArray(), src);
}
/**
* Append IFNONNULL branch instruction to method.
*
* @param src object responsible for generating branch
* @return wrapper for appended conditional branch
*/
public BranchWrapper appendIFNONNULL(Object src) {
verifyStackObject();
BranchHandle hand = m_instructionList.append(new IFNONNULL(null));
setTarget(hand);
m_stackState.pop();
return new BranchWrapper(hand, m_stackState.toArray(), src);
}
/**
* Append IFNULL branch instruction to method.
*
* @param src object responsible for generating branch
* @return wrapper for appended conditional branch
*/
public BranchWrapper appendIFNULL(Object src) {
verifyStackObject();
BranchHandle hand = m_instructionList.append(new IFNULL(null));
setTarget(hand);
m_stackState.pop();
return new BranchWrapper(hand, m_stackState.toArray(), src);
}
/**
* Append IF_ICMPNE branch instruction to method.
*
* @param src object responsible for generating branch
* @return wrapper for appended conditional branch
*/
public BranchWrapper appendIF_ICMPNE(Object src) {
verifyStack("int", "int");
BranchHandle hand = m_instructionList.append(new IF_ICMPNE(null));
setTarget(hand);
m_stackState.pop(2);
return new BranchWrapper(hand, m_stackState.toArray(), src);
}
/**
* Append unconditional branch instruction to method.
*
* @param src object responsible for generating branch
* @return wrapper for appended unconditional branch
*/
public BranchWrapper appendUnconditionalBranch(Object src) {
BranchHandle hand = m_instructionList.append(new GOTO(null));
setTarget(hand);
BranchWrapper wrapper =
new BranchWrapper(hand, m_stackState.toArray(), src);
m_stackState = null;
return wrapper;
}
/**
* Append compound instruction to method.
*
* @param ins instruction to be appended
*/
private void append(CompoundInstruction ins) {
setTarget(m_instructionList.append(ins));
}
/**
* Append instruction to method.
*
* @param ins instruction to be appended
*/
private void append(Instruction ins) {
setTarget(m_instructionList.append(ins));
}
/**
* Create load constant instruction and append to method. Builds the most
* appropriate type of instruction for the value.
*
* @param value constant value to be loaded
*/
public void appendLoadConstant(int value) {
append(m_instructionBuilder.createLoadConstant(value));
m_stackState.push("int");
}
/**
* Create load constant instruction and append to method. Loads a
* String reference from the constant pool.
*
* @param value constant value to be loaded
*/
public void appendLoadConstant(String value) {
if (value != null && value.length() > 0x7FFF) {
throw new IllegalArgumentException("Internal error - value too long");
}
append(m_instructionBuilder.createLoadConstant(value));
m_stackState.push("java.lang.String");
}
/**
* Create load constant instruction and append to method. Loads an
* unwrapped primitive value from the constant pool.
*
* @param value constant value to be loaded
*/
public void appendLoadConstant(Object value) {
append(m_instructionBuilder.createLoadConstant(value));
if (value instanceof Integer || value instanceof Character ||
value instanceof Short || value instanceof Boolean ||
value instanceof Byte) {
m_stackState.push("int");
} else if (value instanceof Long) {
m_stackState.push("long");
} else if (value instanceof Float) {
m_stackState.push("float");
} else if (value instanceof Double) {
m_stackState.push("double");
} else {
throw new IllegalArgumentException("Unknown argument type");
}
}
/**
* Create getfield instruction and append to method. Uses the target field
* information to generate the instruction.
*
* @param item information for field to be gotton
*/
public void appendGetField(ClassItem item) {
verifyStack(item.getClassFile().getName());
append(m_instructionBuilder.createGetField(item));
m_stackState.pop();
m_stackState.push(item.getTypeName());
}
/**
* Create getstatic instruction and append to method. Uses the target field
* information to generate the instruction.
*
* @param item information for field to be set
*/
public void appendGetStatic(ClassItem item) {
append(m_instructionBuilder.createGetStatic(item));
m_stackState.push(item.getTypeName());
}
/**
* Create get instruction and append to method. This generates either a
* getstatic or a getfield instruction, as appropriate.
*
* @param item information for field to be gotten
*/
public void appendGet(ClassItem item) {
if (item.isStatic()) {
appendGetStatic(item);
} else {
appendGetField(item);
}
}
/**
* Create putfield instruction and append to method. Uses the target field
* information to generate the instruction.
*
* @param item information for field to be set
*/
public void appendPutField(ClassItem item) {
String tname = item.getTypeName();
verifyStack(tname, item.getClassFile().getName());
append(m_instructionBuilder.createPutField(item));
m_stackState.pop(2);
}
/**
* Create putstatic instruction and append to method. Uses the target field
* information to generate the instruction.
*
* @param item information for field to be set
*/
public void appendPutStatic(ClassItem item) {
verifyStack(item.getTypeName());
append(m_instructionBuilder.createPutStatic(item));
m_stackState.pop();
}
/**
* Create put instruction and append to method. This generates either a
* putstatic or a putfield instruction, as appropriate.
*
* @param item information for field to be gotten
*/
public void appendPut(ClassItem item) {
if (item.isStatic()) {
appendPutStatic(item);
} else {
appendPutField(item);
}
}
/**
* Create invoke instruction for static, member, or interface method and
* append to method. Uses the target method information to generate the
* correct instruction.
*
* @param item information for method to be called
*/
public void appendCall(ClassItem item) {
// process based on call type
String[] types = item.getArgumentTypes();
int count = types.length;
if (item.getClassFile().isInterface()) {
// process parameters and object reference for interface call
verifyCallStack(item.getClassFile().getName(), types);
append(m_instructionBuilder.createCallInterface(item));
m_stackState.pop(count+1);
} else if ((item.getAccessFlags() & Constants.ACC_STATIC) != 0) {
// process only parameters for static call
verifyCallStack(types);
append(m_instructionBuilder.createCallStatic(item));
if (count > 0) {
m_stackState.pop(count);
}
} else {
// process parameters and object reference for normal method call
verifyCallStack(item.getClassFile().getName(), types);
append(m_instructionBuilder.createCallVirtual(item));
m_stackState.pop(count+1);
}
// adjust stack state to reflect result of call
if (!"void".equals(item.getTypeName())) {
m_stackState.push(item.getTypeName());
}
}
/**
* Create invoke static method instruction from signature and append to
* method.
*
* @param method fully qualified class and method name
* @param signature method signature in standard form
*/
public void appendCallStatic(String method, String signature) {
// verify all call parameters on stack
String[] types = ClassItem.getParametersFromSignature(signature);
verifyCallStack(types);
// generate the actual method call
append(m_instructionBuilder.createCallStatic(method, signature));
// change stack state to reflect result of call
if (types.length > 0) {
m_stackState.pop(types.length);
}
String result = ClassItem.getTypeFromSignature(signature);
if (!"void".equals(result)) {
m_stackState.push(result);
}
}
/**
* Create invoke virtual method instruction from signature and append to
* method.
*
* @param method fully qualified class and method name
* @param signature method signature in standard form
*/
public void appendCallVirtual(String method, String signature) {
// verify all call parameters and object reference on stack
String[] types = ClassItem.getParametersFromSignature(signature);
int split = method.lastIndexOf('.');
if (split < 0) {
throw new IllegalArgumentException
("Internal error: Missing class name on method " + method);
}
verifyCallStack(method.substring(0, split), types);
// generate the actual method call
append(m_instructionBuilder.createCallVirtual(method, signature));
// change stack state to reflect result of call
m_stackState.pop(types.length+1);
String result = ClassItem.getTypeFromSignature(signature);
if (!"void".equals(result)) {
m_stackState.push(result);
}
}
/**
* Create invoke interface method instruction from signature and append to
* method.
*
* @param method fully qualified interface and method name
* @param signature method signature in standard form
*/
public void appendCallInterface(String method, String signature) {
// verify all call parameters and object reference on stack
String[] types = ClassItem.getParametersFromSignature(signature);
int split = method.lastIndexOf('.');
if (split < 0) {
throw new IllegalArgumentException
("Internal error: Missing class name on method " + method);
}
verifyCallStack(method.substring(0, split), types);
// generate the actual method call
append(m_instructionBuilder.createCallInterface(method, signature));
// change stack state to reflect result of call
m_stackState.pop(types.length+1);
String result = ClassItem.getTypeFromSignature(signature);
if (!"void".equals(result)) {
m_stackState.push(result);
}
}
/**
* Append instruction to create instance of class.
*
* @param name fully qualified class name
*/
public void appendCreateNew(String name) {
append(m_instructionBuilder.createNew(name));
m_stackState.push(name);
}
/**
* Create invoke initializer instruction from signature and append to
* method.
*
* @param name fully qualified class name
* @param signature method signature in standard form
*/
public void appendCallInit(String name, String signature) {
// verify all call parameters and object reference on stack
String[] types = ClassItem.getParametersFromSignature(signature);
verifyCallStack(name, types);
// generate the actual method call
append(m_instructionBuilder.createCallInit(name, signature));
// change stack state to reflect result of call
m_stackState.pop(types.length+1);
}
/**
* Append instruction to create instance of array.
*
* @param type fully qualified type name of array elements
*/
public void appendCreateArray(String type) {
if (ClassItem.isPrimitive(type)) {
String sig = Utility.getSignature(type);
append(new NEWARRAY(Utility.typeOfSignature(sig)));
} else if (type.endsWith("[]")) {
String cname = Utility.getSignature(type + "[]");
append(new MULTIANEWARRAY(m_instructionBuilder.
getConstantPoolGen().addClass(cname), (short)1));
} else {
append(new ANEWARRAY(m_instructionBuilder.
getConstantPoolGen().addClass(type)));
}
m_stackState.pop();
m_stackState.push(type + "[]");
}
/**
* Append check cast instruction (if needed).
*
* @param from fully qualified name of current type
* @param to fully qualified name of desired type
*/
public void appendCreateCast(String from, String to) {
// verify current top of stack
verifyStack(from);
// check if any change of type
if (!from.equals(to)) {
// generate instruction and change stack state to match
append(m_instructionBuilder.
createCast(ClassItem.typeFromName(from),
ClassItem.typeFromName(to)));
m_stackState.pop();
m_stackState.push(to);
}
}
/**
* Append check cast instruction from object (if needed).
*
* @param to fully qualified name of desired type
*/
public void appendCreateCast(String to) {
// verify current top of stack
verifyStackObject();
// check if any change of type
if (!m_stackState.peek().equals(to)) {
// generate instruction and change stack state to match
append(m_instructionBuilder.
createCast(Type.OBJECT, ClassItem.typeFromName(to)));
m_stackState.pop();
m_stackState.push(to);
}
}
/**
* Append instanceof check instruction.
*
* @param to fully qualified name of type to check
*/
public void appendInstanceOf(String to) {
// make sure the stack has an object reference
verifyStackObject();
// see if anything actually needs to be checked
if ("java.lang.Object".equals(to)) {
append(InstructionConstants.POP);
appendLoadConstant(1);
} else {
append(m_instructionBuilder.
createInstanceOf((ReferenceType)ClassItem.typeFromName(to)));
}
// change stack state to reflect results of added code
m_stackState.pop();
m_stackState.push("int");
}
/**
* Add local variable to method. The current code in the method must have
* the initial value for the variable on the stack. The scope of the
* variable is defined from the last instruction to the end of the
* method unless otherwise modified.
*
* @param name local variable name (may be null to use default)
* @param type variable type
*/
protected LocalVariableGen createLocal(String name, Type type) {
// verify top of stack
verifyStack(type.toString());
// create name if needed
if (name == null) {
name = "var" + m_generator.getLocalVariables().length;
}
// allocation local and store value
LocalVariableGen var = m_generator.addLocalVariable
(name, type, getLastInstruction(), null);
append(InstructionFactory.createStore(type, var.getIndex()));
// save type information for local variable slot
int slot = var.getIndex();
while (slot >= m_localTypes.size()) {
m_localTypes.add(null);
}
m_localTypes.set(slot, type.toString());
// change stack state to reflect result
m_stackState.pop();
return var;
}
/**
* Add local variable to method. The current code in the method must have
* the initial value for the variable on the stack. The scope of the
* variable is defined from the preceding instruction to the end of the
* method.
*
* @param name local variable name
* @param type variable type
* @return local variable slot number
*/
public int addLocal(String name, Type type) {
LocalVariableGen var = createLocal(name, type);
return var.getIndex();
}
/**
* Append instruction to load local variable.
*
* @param slot local variable slot to load
*/
public void appendLoadLocal(int slot) {
String type = (String)m_localTypes.get(slot);
if (type == null) {
throw new IllegalArgumentException
("Internal error: No variable defined at position " + slot);
}
append(InstructionFactory.
createLoad(ClassItem.typeFromName(type), slot));
m_stackState.push(type);
}
/**
* Append instruction to store local variable.
*
* @param slot local variable slot to store
*/
public void appendStoreLocal(int slot) {
String type = (String)m_localTypes.get(slot);
if (type == null) {
throw new IllegalArgumentException
("Internal error: No variable defined at position " + slot);
}
verifyStack(type);
append(InstructionFactory.
createStore(ClassItem.typeFromName(type), slot));
m_stackState.pop();
}
/**
* Append instruction to increment local integer variable.
*
* @param inc amount of incrment
* @param slot local variable slot to load
*/
public void appendIncrementLocal(int inc, int slot) {
String type = (String)m_localTypes.get(slot);
if (type == null) {
throw new IllegalArgumentException
("Internal error: No variable defined at position " + slot);
} else if (!"int".equals(type)) {
throw new IllegalArgumentException("Internal error: Variable at " +
slot + " is " + type + ", not int");
}
append(new IINC(slot, inc));
}
/**
* Append simple return.
*/
public void appendReturn() {
append(InstructionConstants.RETURN);
m_stackState = null;
}
/**
* Append typed return.
*
* @param type returned type (may be Type.VOID)
*/
public void appendReturn(Type type) {
// verify and return the object reference
if (type != Type.VOID) {
verifyStack(type.toString());
}
append(InstructionFactory.createReturn(type));
// set open stack state for potential continuation code
m_stackState = null;
}
/**
* Append typed return.
*
* @param type returned type (may be void)
*/
public void appendReturn(String type) {
// verify stack and generate return
if ("void".equals(type)) {
append(InstructionConstants.RETURN);
} else {
verifyStack(type);
if (ClassItem.isPrimitive(type)) {
if ("int".equals(type) || "char".equals(type) ||
"short".equals(type) || "boolean".equals(type)) {
append(InstructionConstants.IRETURN);
} else if ("long".equals(type)) {
append(InstructionConstants.LRETURN);
} else if ("float".equals(type)) {
append(InstructionConstants.FRETURN);
} else if ("double".equals(type)) {
append(InstructionConstants.DRETURN);
} else {
throw new IllegalArgumentException("Unknown argument type");
}
} else {
append(InstructionConstants.ARETURN);
}
}
// set open stack state for potential continuation code
m_stackState = null;
}
/**
* Append exception throw.
*/
public void appendThrow() {
append(InstructionConstants.ATHROW);
m_stackState = null;
}
/**
* Append appropriate array load to the instruction list.
*
* @param type array item type expected
*/
public void appendALOAD(String type) {
verifyStack("int");
m_stackState.pop();
verifyArray(type);
if ("byte".equals(type) || "boolean".equals(type)) {
append(InstructionConstants.BALOAD);
} else if ("char".equals(type)) {
append(InstructionConstants.CALOAD);
} else if ("double".equals(type)) {
append(InstructionConstants.DALOAD);
} else if ("float".equals(type)) {
append(InstructionConstants.FALOAD);
} else if ("int".equals(type)) {
append(InstructionConstants.IALOAD);
} else if ("long".equals(type)) {
append(InstructionConstants.LALOAD);
} else if ("short".equals(type)) {
append(InstructionConstants.SALOAD);
} else {
append(InstructionConstants.AALOAD);
}
m_stackState.pop();
m_stackState.push(type);
}
/**
* Append an AASTORE to the instruction list. Doesn't actually check the
* types, just the count of items present.
*/
public void appendAASTORE() {
verifyStackDepth(3);
String vtype = m_stackState.pop();
verifyStack("int");
m_stackState.pop();
String atype = verifyArray();
verifyCompatible(vtype, atype);
m_stackState.pop();
append(InstructionConstants.AASTORE);
}
/**
* Append the appropriate array store to the instruction list.
*
* @param type array item type expected
*/
public void appendASTORE(String type) {
verifyStackDepth(3);
String vtype = m_stackState.pop();
verifyStack("int");
m_stackState.pop();
String atype = verifyArray();
verifyCompatible(vtype, atype);
m_stackState.pop();
if ("byte".equals(type) || "boolean".equals(type)) {
append(InstructionConstants.BASTORE);
} else if ("char".equals(type)) {
append(InstructionConstants.CASTORE);
} else if ("double".equals(type)) {
append(InstructionConstants.DASTORE);
} else if ("float".equals(type)) {
append(InstructionConstants.FASTORE);
} else if ("int".equals(type)) {
append(InstructionConstants.IASTORE);
} else if ("long".equals(type)) {
append(InstructionConstants.LASTORE);
} else if ("short".equals(type)) {
append(InstructionConstants.SASTORE);
} else {
append(InstructionConstants.AASTORE);
}
}
/**
* Append an ACONST_NULL to the instruction list.
*/
public void appendACONST_NULL() {
append(InstructionConstants.ACONST_NULL);
m_stackState.push("");
}
/**
* Append an ARRAYLENGTH to the instruction list.
*/
public void appendARRAYLENGTH() {
verifyArray();
append(InstructionConstants.ARRAYLENGTH);
m_stackState.pop();
m_stackState.push("int");
}
/**
* Append an DCMPG to the instruction list.
*/
public void appendDCMPG() {
verifyStack("double", "double");
append(InstructionConstants.DCMPG);
m_stackState.pop(2);
m_stackState.push("int");
}
/**
* Append a DUP to the instruction list.
*/
public void appendDUP() {
verifyStackDepth(1);
String type = m_stackState.peek();
if ("long".equals(type) || "double".equals(type)) {
throw new IllegalStateException
("Internal error: DUP splits long value");
}
append(InstructionConstants.DUP);
m_stackState.push(m_stackState.peek());
}
/**
* Append a DUP2 to the instruction list.
*/
public void appendDUP2() {
verifyStackDepth(1);
append(InstructionConstants.DUP2);
m_stackState.push(m_stackState.peek());
}
/**
* Append a DUP_X1 to the instruction list.
*/
public void appendDUP_X1() {
verifyStackDepth(2);
String type = m_stackState.peek();
if ("long".equals(type) || "double".equals(type)) {
throw new IllegalStateException
("Internal error: DUP_X1 splits long value");
}
append(InstructionConstants.DUP_X1);
String hold0 = m_stackState.pop();
String hold1 = m_stackState.pop();
m_stackState.push(hold0);
m_stackState.push(hold1);
m_stackState.push(hold0);
}
/**
* Append an FCMPG to the instruction list.
*/
public void appendFCMPG() {
verifyStack("float", "float");
append(InstructionConstants.FCMPG);
m_stackState.pop(2);
m_stackState.push("int");
}
/**
* Append an IASTORE to the instruction list. Doesn't actually check the
* types, just the count of items present.
*/
public void appendIASTORE() {
verifyStackDepth(3);
append(InstructionConstants.IASTORE);
m_stackState.pop(3);
}
/**
* Append an ICONST_0 to the instruction list.
*/
public void appendICONST_0() {
append(InstructionConstants.ICONST_0);
m_stackState.push("int");
}
/**
* Append an ICONST_1 to the instruction list.
*/
public void appendICONST_1() {
append(InstructionConstants.ICONST_1);
m_stackState.push("int");
}
/**
* Append an ISUB to the instruction list.
*/
public void appendISUB() {
verifyStack("int", "int");
append(InstructionConstants.ISUB);
m_stackState.pop(1);
}
/**
* Append an IXOR to the instruction list.
*/
public void appendIXOR() {
verifyStack("int", "int");
append(InstructionConstants.IXOR);
m_stackState.pop(1);
}
/**
* Append an LCMP to the instruction list.
*/
public void appendLCMP() {
verifyStack("long", "long");
append(InstructionConstants.LCMP);
m_stackState.pop(2);
m_stackState.push("int");
}
/**
* Append a POP to the instruction list.
*/
public void appendPOP() {
verifyStackDepth(1);
String type = m_stackState.peek();
if ("long".equals(type) || "double".equals(type)) {
throw new IllegalStateException
("Internal error: POP splits long value");
}
append(InstructionConstants.POP);
m_stackState.pop();
}
/**
* Append a POP2 to the instruction list.
*/
public void appendPOP2() {
verifyStackDepth(1);
String type = m_stackState.peek();
if (!"long".equals(type) && !"double".equals(type)) {
throw new IllegalStateException
("Internal error: POP2 requires long value");
}
append(InstructionConstants.POP2);
m_stackState.pop();
}
/**
* Append a SWAP to the instruction list.
*/
public void appendSWAP() {
verifyStackDepth(2);
append(InstructionConstants.SWAP);
String hold0 = m_stackState.pop();
String hold1 = m_stackState.pop();
m_stackState.push(hold0);
m_stackState.push(hold1);
}
/**
* Append instructions to exchange a single-word value on the top of the
* stack with the double-word value below it on the stack.
*/
public void appendSWAP1For2() {
verifyStackDepth(2);
append(InstructionConstants.DUP_X2);
append(InstructionConstants.POP);
String hold0 = m_stackState.pop();
String hold1 = m_stackState.pop();
m_stackState.push(hold0);
m_stackState.push(hold1);
}
/**
* Append a compound instruction to the list as a branch target.
*
* @param inst compound instruction to be appended as branch target
* @return branch target information
*/
private BranchTarget appendTargetInstruction(CompoundInstruction inst) {
String[] types = m_stackState.toArray();
InstructionHandle hand = m_instructionList.append(inst);
return new BranchTarget(hand, types);
}
/**
* Append an instruction to the list as a branch target.
*
* @param inst instruction to be appended as branch target
* @return branch target information
*/
private BranchTarget appendTargetInstruction(Instruction inst) {
String[] types = m_stackState.toArray();
InstructionHandle hand = m_instructionList.append(inst);
return new BranchTarget(hand, types);
}
/**
* Append a NOP to the instruction list as a branch target.
*
* @return branch target information
*/
public BranchTarget appendTargetNOP() {
return appendTargetInstruction(InstructionConstants.NOP);
}
/**
* Append an ACONST_NULL to the instruction list as a branch target.
*
* @return branch target information
*/
public BranchTarget appendTargetACONST_NULL() {
BranchTarget target = appendTargetInstruction
(InstructionConstants.ACONST_NULL);
m_stackState.push("");
return target;
}
/**
* Append a load constant instruction as a branch target. Builds the most
* appropriate type of instruction for the value.
*
* @param value constant value to be loaded
* @return branch target information
*/
public BranchTarget appendTargetLoadConstant(int value) {
BranchTarget target = appendTargetInstruction(m_instructionBuilder.
createLoadConstant(value));
m_stackState.push("int");
return target;
}
/**
* Append a load constant instruction as a branch target. Loads a
* String reference from the constant pool.
*
* @param value constant value to be loaded
* @return branch target information
*/
public BranchTarget appendTargetLoadConstant(String value) {
BranchTarget target = appendTargetInstruction(m_instructionBuilder.
createLoadConstant(value));
m_stackState.push("java.lang.String");
return target;
}
/**
* Append instruction to create instance of class as a branch target.
*
* @param name fully qualified class name
* @return branch target information
*/
public BranchTarget appendTargetCreateNew(String name) {
BranchTarget target =
appendTargetInstruction(m_instructionBuilder.createNew(name));
m_stackState.push(name);
return target;
}
/**
* Internal append instruction to create instance of class. This is used by
* subclasses when they need access to the actual instruction handle.
*
* @param name fully qualified class name
*/
protected InstructionHandle internalAppendCreateNew(String name) {
InstructionHandle handle = m_instructionList.append
(m_instructionBuilder.createNew(name));
m_stackState.push(name);
return handle;
}
/**
* Check if top item on stack is a long value.
*
* @return true if long value, false if not
*/
public boolean isStackTopLong() {
verifyStackDepth(1);
String type = m_stackState.peek();
return "long".equals(type) || "double".equals(type);
}
/**
* Initialize stack state to match branch source. This can be used to set
* the expected stack state following an unconditional transfer of control
* instruction. The principle here is that the code to be generated must be
* reached by a branch, so the stack state must match that of the branch
* source.
*
* @param branch wrapper for branch to be for stack initialization
*/
public void initStackState(BranchWrapper branch) {
m_stackState = new StringStack(branch.getStackState());
}
/**
* Initialize stack state to partially match branch source. This can be used
* to set the expected stack state following an unconditional transfer of
* control instruction. The specified number of items are removed from the
* branch stack, with the assumption that code to add these items will be
* appended before the branch join point is reached.
*
* @param branch wrapper for branch to be for stack initialization
* @param pop number of items to be removed from branch source stack state
*/
public void initStackState(BranchWrapper branch, int pop) {
m_stackState = new StringStack(branch.getStackState());
if (pop > 0) {
m_stackState.pop(pop);
}
}
/**
* Initialize stack state to array of value types. This can be used to set
* the expected stack state following an unconditional transfer of control
* instruction.
*
* @param types array of type names on stack
*/
protected void initStackState(String[] types) {
m_stackState = new StringStack(types);
}
/**
* Set branch target as next instruction added to method. This effectively
* sets up a state trigger for the next append operation. The appended
* instruction is set as the target for the branch. This requires that
* instructions are only appended using the methods supplied in this class.
*
* @param branch wrapper for branch to be aimed at next instruction (may be
* null, in which case nothing is done)
*/
public void targetNext(BranchWrapper branch) {
if (branch != null) {
if (m_targetBranches == null) {
m_targetBranches = new BranchWrapper[] { branch };
if (m_stackState == null) {
m_stackState = new StringStack(branch.getStackState());
}
} else {
int length = m_targetBranches.length;
BranchWrapper[] wrappers = new BranchWrapper[length+1];
System.arraycopy(m_targetBranches, 0, wrappers, 0, length);
wrappers[length] = branch;
m_targetBranches = wrappers;
}
}
}
/**
* Set branch targets as next instruction added to method. This effectively
* sets up a state trigger for the next append operation. The appended
* instruction is set as the target for all the branches. This requires that
* instructions are only appended using the methods supplied in this class.
*
* @param branches wrappers for branches to be aimed at next instruction
* (may be null, in which case nothing is done)
*/
public void targetNext(BranchWrapper[] branches) {
if (branches != null && branches.length > 0) {
if (m_targetBranches == null) {
m_targetBranches = branches;
if (m_stackState == null) {
m_stackState = new StringStack(branches[0].getStackState());
}
} else {
int offset = m_targetBranches.length;
int length = offset + branches.length;
BranchWrapper[] wrappers = new BranchWrapper[length];
System.arraycopy(m_targetBranches, 0, wrappers, 0, offset);
System.arraycopy(branches, 0, wrappers, offset,
branches.length);
m_targetBranches = wrappers;
}
}
}
/**
* Process accumulated exceptions. Each subclass must implement this
* method to perform the appropriate handling of the checked exceptions
* that may be thrown in the constructed method.
*/
protected abstract void handleExceptions();
/**
* Complete method construction. Finalizes the instruction list and
* generates the byte code for the constructed method, then computes the
* hash code based on the byte code. If requested, an appropriate suffix is
* tacked on the end of the supplied name in order to make sure that it will
* not be duplicated (even in a superclass or subclass).
*
* @param suffix add suffix to make method name unique
*/
public void codeComplete(boolean suffix) {
if (m_targetBranches != null) {
throw new IllegalStateException
("Method complete with pending branch target");
}
if (m_exceptions != null) {
handleExceptions();
}
if (suffix) {
m_generator.setName(getClassFile().
makeUniqueMethodName(m_generator.getName()));
}
m_generator.setMaxStack();
m_generator.setMaxLocals();
m_instructionList.setPositions(true);
m_method = m_generator.getMethod();
m_instructionList.dispose();
m_hashCode = computeMethodHash(m_method);
}
/**
* Get the method item.
*
* @return method item information
*/
public ClassItem getItem() {
if (m_item == null) {
throw new IllegalStateException("Method not added to class");
} else {
return m_item;
}
}
/**
* Get hash code. This is based only on the byte code in the method, and
* is only valid after the {@link #codeComplete} method is called.
*
* @return hash code based on code sequence
*/
public int hashCode() {
if (m_method == null) {
throw new IllegalStateException("Method still under construction");
} else {
return m_hashCode;
}
}
/**
* Add constructed method to class. Makes the method callable, generating
* the method information.
*
* @return added method information
*/
public ClassItem addMethod() {
if (m_method == null) {
throw new IllegalStateException("Method not finalized.");
} else {
m_item = getClassFile().addMethod(m_method);
return m_item;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/BranchWrapper.java 0000644 0001750 0001750 00000017661 10270431156 026331 0 ustar twerner twerner /*
Copyright (c) 2004, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.classes;
import org.apache.bcel.generic.BranchHandle;
import org.apache.bcel.generic.InstructionHandle;
/**
* Wrapper for branch handle. This preserves a snapshot of the stack state for
* the branch instruction, matching it against the stack state for the target
* instruction when set.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class BranchWrapper
{
/** Track source code location for generated branches. */
private static boolean s_trackSource;
/** Continue on after code generation error flag. */
private static boolean s_errorOverride;
/** Actual wrapped instruction handle. */
private final BranchHandle m_branchHandle;
/** Stack state for branch origin. */
private final String[] m_stackTypes;
/** Object that generated branch. */
private final Object m_sourceObject;
/** Code generation backtrace for source of branch. */
private final Throwable m_sourceTrace;
/**
* Constructor.
*
* @param hand branch handle
* @param types array of types of values on stack
* @param src object responsible for generating branch
*/
/*package*/ BranchWrapper(BranchHandle hand, String[] types, Object src) {
m_branchHandle = hand;
m_stackTypes = types;
m_sourceObject = src;
if (s_trackSource) {
m_sourceTrace = new Throwable();
} else {
m_sourceTrace = null;
}
}
/**
* Get branch origin stack state information.
*
* @return array of types of values on stack
*/
/*package*/ String[] getStackState() {
return m_stackTypes;
}
/**
* Generate description of stack state.
*
* @param types array of types on stack
* @return stack state description
*/
private String describeStack(String[] types) {
StringBuffer buff = new StringBuffer();
for (int i = 0; i < types.length; i++) {
buff.append(" ");
buff.append(i);
buff.append(": ");
buff.append(types[i]);
buff.append('\n');
}
return buff.toString();
}
/**
* Report branch target error. Dumps the stack trace for the source of the
* branch, if source tracking is enabled, and generates an exception that
* includes the stack state information.
*
* @param text basic error message text
* @param types stack state description
* @param mb method builder using this code
* @return complete error description text
*/
private String buildReport(String text, String[] types, MethodBuilder mb) {
// start by dumping branch generation source trace
if (m_sourceTrace != null) {
System.err.println("Backtrack for branch source:");
m_sourceTrace.printStackTrace(System.err);
}
// generate error message leading text
StringBuffer buff = new StringBuffer(text);
buff.append("\n in method ");
buff.append(mb.getClassFile().getName());
buff.append('.');
buff.append(mb.getName());
buff.append("\n generated by ");
buff.append(m_sourceObject.toString());
buff.append("\n from stack:\n");
buff.append(describeStack(m_stackTypes));
buff.append(" to stack:\n");
buff.append(describeStack(types));
return buff.toString();
}
/**
* Set target instruction for branch. Validates the branch source stack
* state against the branch target stack state.
*
* @param hand target branch instruction handle
* @param types stack state description
* @param mb method builder using this code
*/
/*package*/ void setTarget(InstructionHandle hand, String[] types,
MethodBuilder mb) {
// match stack states
if (types.length == m_stackTypes.length) {
for (int i = 0; i < types.length; i++) {
String stype = m_stackTypes[i];
if (!types[i].equals(stype)) {
if (!"".equals(types[i]) && !"".equals(stype)) {
if (m_sourceTrace != null) {
System.err.println("Backtrack for branch source:");
m_sourceTrace.printStackTrace(System.err);
}
String text = buildReport
("Stack value type mismatch on branch", types, mb);
if (s_errorOverride) {
new Throwable(text).printStackTrace(System.err);
} else {
throw new IllegalStateException(text);
}
}
}
}
} else {
String text =
buildReport("Stack size mismatch on branch", types, mb);
if (s_errorOverride) {
new Throwable(text).printStackTrace(System.err);
} else {
throw new IllegalStateException(text);
}
}
// set the branch target
m_branchHandle.setTarget(hand);
}
/**
* Set target instruction for branch. Validates the branch source stack
* state against the branch target stack state.
*
* @param target branch target wrapper
* @param mb method builder using this code
*/
public void setTarget(BranchTarget target, MethodBuilder mb) {
setTarget(target.getInstruction(), target.getStack(), mb);
}
/**
* Set branch code generation tracking state. When set, this saves a stack
* trace for each generated branch instruction, allowing the source of a
* branch to be traced when an error occurs in setting the branch target.
*
* @param track true to enable branch code generation tracking,
* false to disable it
*/
public static void setTracking(boolean track) {
s_trackSource = track;
}
/**
* Set target setting error override state. When set, this blocks throwing
* an exception when an error occurs on setting the branch target, instead
* just printing the information to the console.
*
* @param over true to override exception on target error,
* false to allow it
*/
public static void setErrorOverride(boolean over) {
s_errorOverride = over;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/ExceptionMethodBuilder.java 0000644 0001750 0001750 00000012072 11033613304 030163 0 ustar twerner twerner /*
Copyright (c) 2003-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.classes;
import java.util.HashMap;
import org.apache.bcel.Constants;
import org.apache.bcel.generic.LocalVariableGen;
import org.apache.bcel.generic.Type;
/**
* Builder for simple methods that may just pass checked exceptions on to
* caller.
*
* @author Dennis M. Sosnoski
*/
public class ExceptionMethodBuilder extends MethodBuilder
{
/** Map for object to variable assignments. */
private HashMap m_slotMap;
/**
* Constructor with types specified.
*
* @param name method name to be built
* @param ret method return type
* @param args types of arguments
* @param cf owning class file information
* @param access flags for method access
*/
public ExceptionMethodBuilder(String name, Type ret, Type[] args,
ClassFile cf, int access) {
super(name, ret, args, cf, access);
}
/**
* Constructor from signature.
*
* @param name method name to be built
* @param sig method signature
* @param cf owning class file information
* @param access flags for method access
*/
public ExceptionMethodBuilder(String name, String sig,
ClassFile cf, int access) {
super(name, Type.getReturnType(sig), Type.getArgumentTypes(sig),
cf, access);
}
/**
* Constructor from signature for public, final method.
*
* @param name method name to be built
* @param sig method signature
* @param cf owning class file information
*/
public ExceptionMethodBuilder(String name, String sig, ClassFile cf) {
super(name, Type.getReturnType(sig), Type.getArgumentTypes(sig),
cf, Constants.ACC_PUBLIC | Constants.ACC_FINAL);
}
/**
* Define local variable slot for object. The current code in the method
* must have the initial value for the variable on the stack
*
* @param obj owning object of slot
* @param type variable type
* @return slot number
*/
public int defineSlot(Object obj, Type type) {
if (m_slotMap == null) {
m_slotMap = new HashMap();
}
LocalVariableGen var = createLocal("var" + m_slotMap.size(), type);
m_slotMap.put(obj, var);
return var.getIndex();
}
/**
* Check if local variable slot defined for object.
*
* @param obj owning object of slot
* @return local variable slot assigned to object, or -1 if
* none
*/
public int getSlot(Object obj) {
if (m_slotMap != null) {
LocalVariableGen var = (LocalVariableGen)m_slotMap.get(obj);
if (var != null) {
return var.getIndex();
}
}
return -1;
}
/**
* Free local variable slot for object. This clears the usage of the slot
* (if one has been defined for the object) so it can be reused for other
* purposes.
*
* @param obj owning object of slot
*/
public void freeSlot(Object obj) {
if (m_slotMap != null) {
LocalVariableGen var = (LocalVariableGen)m_slotMap.get(obj);
if (var != null) {
var.setEnd(getLastInstruction());
m_slotMap.remove(obj);
}
}
}
/**
* Process accumulated exceptions. Just adds the checked exceptions that
* may be thrown within the body to the list for this method, passing them
* on to the caller for handling.
*/
protected void handleExceptions() {
for (int i = 0; i < m_exceptions.size(); i++) {
m_generator.addException((String)m_exceptions.get(i));
}
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/BindingMethod.java 0000644 0001750 0001750 00000015737 10210703666 026312 0 ustar twerner twerner /*
Copyright (c) 2003-2005, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.classes;
import org.apache.bcel.Constants;
import org.apache.bcel.classfile.ExceptionTable;
import org.apache.bcel.classfile.Method;
/**
* Binding method information. Tracks a method used by the binding code,
* supplying hash code and equality checking based on the method signature and
* actual byte code of the method, ignoring the method name. This allows
* comparisons between methods generated by different bindings, and between
* generated and existing methods.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public abstract class BindingMethod
{
/** Owning class file information. */
private ClassFile m_classFile;
/**
* Constructor.
*
* @param cf owning class file information
*/
protected BindingMethod(ClassFile cf) {
m_classFile = cf;
}
/**
* Get class file containing method.
*
* @return class file owning this method
*/
public ClassFile getClassFile() {
return m_classFile;
}
/**
* Get name of method. This abstract method must be implemented by every
* subclass.
*
* @return method name
*/
public abstract String getName();
/**
* Get signature. This abstract method must be implemented by every
* subclass.
*
* @return signature for method
*/
public abstract String getSignature();
/**
* Get access flags. This abstract method must be implemented by every
* subclass.
*
* @return flags for access type of method
*/
public abstract int getAccessFlags();
/**
* Set access flags. This abstract method must be implemented by every
* subclass.
*
* @param flags access type to be set
*/
public abstract void setAccessFlags(int flags);
/**
* Get the actual method.
*
* @return method information
*/
public abstract Method getMethod();
/**
* Get the method item.
*
* @return method item information
*/
public abstract ClassItem getItem();
/**
* Make accessible method. Check if this method is accessible from another
* class, and if not decreases the access restrictions to make it
* accessible.
*
* @param src class file for required access
*/
public void makeAccessible(ClassFile src) {
// no need to change if already public access
int access = getAccessFlags();
if ((access & Constants.ACC_PUBLIC) == 0) {
// check for same package as most restrictive case
ClassFile dest = getClassFile();
if (dest.getPackage().equals(src.getPackage())) {
if ((access & Constants.ACC_PRIVATE) != 0) {
access = access - Constants.ACC_PRIVATE;
}
} else {
// check if access is from a subclass of this method class
ClassFile ancestor = src;
while ((ancestor = ancestor.getSuperFile()) != null) {
if (ancestor == dest) {
break;
}
}
// handle access adjustments based on subclass status
if (ancestor == null) {
int clear = Constants.ACC_PRIVATE |
Constants.ACC_PROTECTED;
access = (access & ~clear) | Constants.ACC_PUBLIC;
} else if ((access & Constants.ACC_PROTECTED) == 0) {
access = (access & ~Constants.ACC_PRIVATE) |
Constants.ACC_PROTECTED;
}
}
// set new access flags
if (access != getAccessFlags()) {
setAccessFlags(access);
}
}
}
/**
* Computes the hash code for a method. The hash code is based on the
* method signature, the exceptions thrown, and the actual byte code
* (including the exception handlers).
*
* @return computed hash code for method
*/
public static int computeMethodHash(Method method) {
int hash = method.getSignature().hashCode();
ExceptionTable etab = method.getExceptionTable();
if (etab != null) {
String[] excepts = etab.getExceptionNames();
for (int i = 0; i < excepts.length; i++) {
hash += excepts[i].hashCode();
}
}
byte[] code = method.getCode().getCode();
for (int i = 0; i < code.length; i++) {
hash = hash * 49 + code[i];
}
return hash;
}
/**
* Get hash code. This abstract method must be implemented by every
* subclass, using the same algorithm in each case. See one of the existing
* subclasses for details.
*
* @return hash code for this method
*/
public abstract int hashCode();
/**
* Check if objects are equal. Compares first based on hash code, then on
* the actual byte code sequence.
*
* @return true if equal objects, false if not
*/
public boolean equals(Object obj) {
if (obj instanceof BindingMethod) {
BindingMethod comp = (BindingMethod)obj;
if (hashCode() == comp.hashCode() &&
getSignature().equals(comp.getSignature())) {
return ClassFile.equalMethods
(this.getMethod(), comp.getMethod());
}
}
return false;
}
}
libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/ExistingMethod.java 0000644 0001750 0001750 00000010213 11033613304 026503 0 ustar twerner twerner /*
Copyright (c) 2003-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.classes;
import org.apache.bcel.classfile.Method;
/**
* Information for an existing binding method. It supplies hash code and
* equality checking based on the method signature and actual byte code of the
* generated method, ignoring the method name.
*
* @author Dennis M. Sosnoski
*/
public class ExistingMethod extends BindingMethod
{
/** Class item information. */
private ClassItem m_item;
/** Actual method information. */
private Method m_method;
/** Accumulated hash code from adding instructions. */
private int m_hashCode;
/** Flag for method used in code. */
private boolean m_used;
/**
* Constructor.
*
* @param method actual method information
* @param item class item information for method
* @param file class file information
*/
public ExistingMethod(Method method, ClassItem item, ClassFile file) {
super(file);
m_item = item;
m_method = method;
m_hashCode = computeMethodHash(method);
// System.out.println("Computed hash for existing method " +
// m_classFile.getName() + '.' + method.getName() + " as " + m_hashCode);
}
/**
* Get name of method.
*
* @return method name
*/
public String getName() {
return m_item.getName();
}
/**
* Get signature.
*
* @return signature for method
*/
public String getSignature() {
return m_item.getSignature();
}
/**
* Get access flags.
*
* @return flags for access type of method
*/
public int getAccessFlags() {
return m_item.getAccessFlags();
}
/**
* Set access flags.
*
* @param flags access type to be set
*/
public void setAccessFlags(int flags) {
m_item.setAccessFlags(flags);
}
/**
* Check method used status.
*
* @return method used status
*/
public boolean isUsed() {
return m_used;
}
/**
* Set method used status.
*/
public void setUsed() {
m_used = true;
}
/**
* Get the actual method.
*
* @return method information
*/
public Method getMethod() {
return m_method;
}
/**
* Get the method item.
*
* @return method item information
*/
public ClassItem getItem() {
return m_item;
}
/**
* Delete method from class.
*/
public void delete() {
getClassFile().removeMethod(m_method);
}
/**
* Get hash code.
*
* @return hash code for this method
*/
public int hashCode() {
return m_hashCode;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/BoundClass.java 0000644 0001750 0001750 00000043601 11321646232 025622 0 ustar twerner twerner /*
* Copyright (c) 2003-2009, Dennis M. Sosnoski. 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. Neither the name of JiBX nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 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 OWNER 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.jibx.binding.classes;
import java.io.File;
import java.util.HashMap;
import org.apache.bcel.Constants;
import org.apache.bcel.classfile.Utility;
import org.apache.bcel.generic.Type;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.JiBXException;
/**
* Bound class handler. Each instance controls and organizes information for a
* class included in one or more binding definitions.
*
* @author Dennis M. Sosnoski
*/
public class BoundClass
{
//
// Constants and such related to code generation.
/** Prefix used for access methods. */
private static final String ACCESS_PREFIX = BindingDirectory.GENERATE_PREFIX
+ "access_";
/** Empty argument type array. */
private static final Type[] EMPTY_TYPE_ARGS = {};
//
// Static data.
/**
* Map from bound class name (or bound and munged combination) to binding
* information.
*/
private static HashMap s_nameMap;
/** Package of first modifiable class. */
private static String s_modifyPackage;
/** Root for package of first modifiable class. */
private static File s_modifyRoot;
/** Name to be used for code generation proxy class. */
private static String s_mungeName = BindingDirectory.GENERATE_PREFIX +
"MungeAdapter";
/** Class used for code generation proxy with unmodifiable classes (lazy
create, null if not yet needed). */
private static MungedClass s_genericMunge;
//
// Actual instance data.
/** Bound class file information. */
private final ClassFile m_boundClass;
/** Class receiving code generated for target class. */
private final MungedClass m_mungedClass;
/**
* Map from field or method to load access method (lazy create,
* null if not used).
*/
private HashMap m_loadMap;
/**
* Map from field or method to store access method (lazy create,
* null if not used).
*/
private HashMap m_storeMap;
/**
* Constructor.
*
* @param bound target class file information
* @param munge class file for class hosting generated code
*/
private BoundClass(ClassFile bound, MungedClass munge) {
m_boundClass = bound;
m_mungedClass = munge;
}
/**
* Get bound class file information.
*
* @return class file information for bound class
*/
public ClassFile getClassFile() {
return m_boundClass;
}
/**
* Get bound class file name.
*
* @return name of bound class
*/
public String getClassName() {
return m_boundClass.getName();
}
/**
* Get munged class file information.
*
* @return class file information for class being modified
*/
public ClassFile getMungedFile() {
return m_mungedClass.getClassFile();
}
/**
* Check if class being changed directly.
*
* @return true if bound class is being modified,
* false if using a surrogate
*/
public boolean isDirectAccess() {
return m_boundClass == m_mungedClass.getClassFile();
}
/**
* Get load access method for member of this class. If the access method
* does not already exist it's created by this call. If the access method
* does exist but without access from the context class, the access
* permission on the method is broadened (from package to protected or
* public, or from protected to public).
*
* @param item field or method to be accessed
* @param from context class from which access is required
* @return the item itself if it's accessible from the required context, an
* access method that is accessible if the item is not itself
* @throws JiBXException on configuration error
*/
public ClassItem getLoadMethod(ClassItem item, ClassFile from)
throws JiBXException {
// initialize tracking information for access methods if first time
if (m_loadMap == null) {
m_loadMap = new HashMap();
}
// check if a new access method needed
BindingMethod method = (BindingMethod)m_loadMap.get(item);
if (method == null) {
// set up for constructing new method
String name = ACCESS_PREFIX + "load_" + item.getName();
ClassFile cf = item.getClassFile();
Type type = Type.getType(Utility.getSignature(item.getTypeName()));
MethodBuilder mb = new ExceptionMethodBuilder(name, type,
EMPTY_TYPE_ARGS, cf, Constants.ACC_PUBLIC);
// add the actual access method code
mb.appendLoadLocal(0);
if (item.isMethod()) {
mb.addMethodExceptions(item);
mb.appendCall(item);
} else {
mb.appendGetField(item);
}
mb.appendReturn(type);
// track unique instance of this method
method = m_mungedClass.getUniqueMethod(mb, true);
m_loadMap.put(item, method);
}
// make sure method is accessible
method.makeAccessible(from);
return method.getItem();
}
/**
* Get store access method for member of this class. If the access method
* does not already exist it's created by this call. If the access method
* does exist but without access from the context class, the access
* permission on the method is broadened (from package to protected or
* public, or from protected to public).
*
* @param item field or method to be accessed
* @param from context class from which access is required
* @return the item itself if it's accessible from the required context, an
* access method that is accessible if the item is not itself
* @throws JiBXException on configuration error
*/
public ClassItem getStoreMethod(ClassItem item, ClassFile from)
throws JiBXException {
// initialize tracking information for access methods if first time
if (m_storeMap == null) {
m_storeMap = new HashMap();
}
// check if a new access method needed
BindingMethod method = (BindingMethod)m_storeMap.get(item);
if (method == null) {
// set up for constructing new method
String name = ACCESS_PREFIX + "store_" + item.getName();
ClassFile cf = item.getClassFile();
Type type;
if (item.isMethod()) {
String sig = item.getSignature();
int start = sig.indexOf('(');
int end = sig.indexOf(')');
type = Type.getType(sig.substring(start + 1, end));
} else {
type = Type.getType(Utility.getSignature(item.getTypeName()));
}
MethodBuilder mb = new ExceptionMethodBuilder(name, Type.VOID,
new Type[] { type }, cf, Constants.ACC_PUBLIC);
// add the actual access method code
mb.appendLoadLocal(0);
mb.appendLoadLocal(1);
if (item.isMethod()) {
mb.addMethodExceptions(item);
mb.appendCall(item);
} else {
mb.appendPutField(item);
}
mb.appendReturn();
// track unique instance of this method
method = m_mungedClass.getUniqueMethod(mb, true);
m_storeMap.put(item, method);
}
// make sure method is accessible
method.makeAccessible(from);
return method.getItem();
}
/**
* Get unique method. Just delegates to the modified class handling, with
* unique suffix appended to method name.
*
* @param builder method to be defined
* @return defined method item
* @throws JiBXException on configuration error
*/
public BindingMethod getUniqueMethod(MethodBuilder builder)
throws JiBXException {
return m_mungedClass.getUniqueMethod(builder, true);
}
/**
* Get unique method. Just delegates to the modified class handling. The
* supplied name is used without change.
*
* @param builder method to be defined
* @return defined method item
* @throws JiBXException on configuration error
*/
public BindingMethod getUniqueNamed(MethodBuilder builder)
throws JiBXException {
return m_mungedClass.getUniqueMethod(builder, false);
}
/**
* Add binding factory to class. Makes sure that there's no surrogate class
* for code generation, then delegates to the modified class handling.
*
* @param fact binding factory name
*/
public void addFactory(String fact) {
if (isDirectAccess()) {
m_mungedClass.addFactory(fact);
} else {
throw new IllegalStateException(
"Internal error: not directly modifiable class");
}
}
/**
* Generate factory list. Makes sure that there's no surrogate class for
* code generation, then delegates to the modified class handling.
*
* @throws JiBXException on configuration error
*/
public void setFactoryList() throws JiBXException {
if (isDirectAccess()) {
m_mungedClass.setFactoryList();
} else {
throw new IllegalStateException(
"Internal error: not directly modifiable class");
}
}
/**
* Create binding information for class. This creates the combination of
* bound class and (if different) munged class and adds it to the internal
* tables.
*
* @param key text identifier for this bound class and munged class
* combination
* @param bound class information for bound class
* @param munge information for surrogate class receiving generated code, or
* null if no separate class
* @return binding information for class
*/
private static BoundClass createInstance(String key, ClassFile bound,
MungedClass munge) {
BoundClass inst = new BoundClass(bound, munge);
s_nameMap.put(key, inst);
return inst;
}
/**
* Find or create binding information for class. If the combination of bound
* class and munged class already exists it's returned directly, otherwise
* it's created and returned.
*
* @param bound class information for bound class
* @param munge information for surrogate class receiving generated code
* @return binding information for class
*/
private static BoundClass findOrCreateInstance(ClassFile bound,
MungedClass munge) {
String key = bound.getName() + ':' + munge.getClassFile().getName();
BoundClass inst = (BoundClass)s_nameMap.get(key);
if (inst == null) {
inst = createInstance(key, bound, munge);
}
return inst;
}
/**
* Get binding information for class. This finds the class in which code
* generation for the target class takes place. Normally this class will be
* the target class itself, but in cases where the target class is not
* modifiable an alternate class will be used. This can take two forms. If
* the context class is provided and it is a subclass of the target class,
* code for the target class is instead added to the context class. If there
* is no context class, or if the context class is not a subclass of the
* target class, a unique catch-all class is used.
*
* @param cf bound class information
* @param context context class for code generation, or null
* if no context
* @return binding information for class
* @throws JiBXException on configuration error
*/
public static BoundClass getInstance(ClassFile cf, BoundClass context)
throws JiBXException {
// check if new instance needed for this class
BoundClass inst = (BoundClass)s_nameMap.get(cf.getName());
if (inst == null) {
// load the basic class information and check for modifiable
if (!cf.isInterface() && cf.isModifiable()) {
// return instance directly
inst = createInstance(cf.getName(), cf, MungedClass
.getInstance(cf));
} else {
// see if the context class is a subclass
if (context != null
&& context.getClassFile().isSuperclass(cf.getName())) {
// find or create munge with subclass as surrogate
inst = findOrCreateInstance(cf, context.m_mungedClass);
} else {
// use catch-all munge class as surrogate for all else
if (s_genericMunge == null) {
String mname;
if (s_modifyPackage == null) {
mname = s_mungeName;
MungedClass.checkDirectory(s_modifyRoot, "");
} else {
mname = s_modifyPackage + '.' + s_mungeName;
MungedClass.checkDirectory(s_modifyRoot,
s_modifyPackage);
}
ClassFile base = ClassCache
.requireClassFile("java.lang.Object");
int acc = Constants.ACC_PUBLIC | Constants.ACC_ABSTRACT;
ClassFile gen = new ClassFile(mname, s_modifyRoot,
base, acc, new String[0]);
gen.addDefaultConstructor();
s_genericMunge = MungedClass.getInstance(gen);
MungedClass.delayedAddUnique(gen);
}
inst = findOrCreateInstance(cf, s_genericMunge);
}
}
}
return inst;
}
/**
* Get binding information for class. This version takes a fully-qualified
* class name, calling the paired method if necessary to create a new
* instance.
*
* @param name fully qualified name of bound class
* @param context context class for code generation, or null
* if no context
* @return binding information for class
* @throws JiBXException on configuration error
*/
public static BoundClass getInstance(String name, BoundClass context)
throws JiBXException {
// check if new instance needed for this class
BoundClass inst = (BoundClass)s_nameMap.get(name);
if (inst == null) {
ClassFile cf = ClassCache.requireClassFile(name);
return getInstance(cf, context);
}
return inst;
}
/**
* Discard cached information and reset in preparation for a new binding
* run.
*/
public static void reset() {
s_nameMap = new HashMap();
s_modifyPackage = null;
s_modifyRoot = null;
s_genericMunge = null;
s_mungeName = null;
}
/**
* Set override modification information. This allows the binding to
* control directly the root directory and package for added classes, and
* also to set the binding name used as a modifier on the generic munge
* adapter class.
*
* @param root classpath root directory for added classes
* @param pkg package for added classes
* @param name binding name
*/
public static void setModify(File root, String pkg, String name) {
s_modifyRoot = root;
s_modifyPackage = pkg;
if (s_modifyPackage.length() == 0) {
s_modifyPackage = null;
}
s_mungeName = BindingDirectory.GENERATE_PREFIX + name + "MungeAdapter";
}
/**
* Derive generated class name for bound class. This generates a JiBX class
* name from the name of this class, using the supplied prefix and suffix
* information. The derived class name is always in the same package as the
* munged class for this class.
*
* @param prefix generated class name prefix
* @param suffix generated class name suffix
* @return derived class name
*/
public String deriveClassName(String prefix, String suffix) {
String pack = m_mungedClass.getClassFile().getPackage();
if (pack.length() > 0) {
pack += '.';
}
String tname = m_boundClass.getName();
int split = tname.lastIndexOf('.');
if (split >= 0) {
tname = tname.substring(split + 1);
}
return pack + prefix + tname + suffix;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/MarshalUnmarshalBuilder.java 0000644 0001750 0001750 00000007475 11033613304 030341 0 ustar twerner twerner /*
Copyright (c) 2003-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.classes;
import org.apache.bcel.generic.InstructionHandle;
import org.apache.bcel.generic.ObjectType;
import org.apache.bcel.generic.Type;
/**
* Builder for marshal and unmarshal methods. Adds exception accumulation with
* actual handling provided by the subclass.
*
* @author Dennis M. Sosnoski
*/
public abstract class MarshalUnmarshalBuilder extends ContextMethodBuilder
{
/**
* Constructor. This sets up for constructing the marshal or unmarshal
* method.
*
* @param name method name to be built
* @param ret method return type
* @param args types of arguments
* @param mf method generation class file information
* @param access flags for method access
* @param obj variable slot for current object
* @param type marshalled or unmarshalled class name
* @param ctx variable slot for marshalling/unmarshalling context
* @param ctype context type as defined in method
*/
protected MarshalUnmarshalBuilder(String name, Type ret, Type[] args,
ClassFile mf, int access, int obj, String type, int ctx, String ctype) {
super(name, ret, args, mf, access, obj, type, ctx, ctype);
}
/**
* Add exception handler code. This method must be implemented by each
* subclass to provide the appropriate handling code.
*
* @return handle for first instruction in handler
*/
public abstract InstructionHandle genExceptionHandler();
/**
* Process accumulated exceptions. Sets up an exception handler framework
* and then calls the {@link #genExceptionHandler} method to build the
* handler body.
*/
protected void handleExceptions() {
int index = m_exceptions.indexOf(FRAMEWORK_EXCEPTION_CLASS);
if (index >= 0) {
m_generator.addException(FRAMEWORK_EXCEPTION_CLASS);
m_exceptions.remove(index);
}
if (m_exceptions.size() > 0) {
InstructionHandle begin = getFirstInstruction();
InstructionHandle end = getLastInstruction();
InstructionHandle handle = genExceptionHandler();
for (int i = 0; i < m_exceptions.size(); i++) {
m_generator.addExceptionHandler(begin, end, handle,
(ObjectType)ClassItem.
typeFromName((String)m_exceptions.get(i)));
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/ContextMethodBuilder.java 0000644 0001750 0001750 00000017006 11033613304 027653 0 ustar twerner twerner /*
Copyright (c) 2003-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.classes;
import org.apache.bcel.Constants;
import org.apache.bcel.generic.LocalVariableGen;
import org.apache.bcel.generic.Type;
/**
* Builder for binding methods with a context and, optionally, a current object.
* Tracks the current object reference and the context object reference
* positions in the local variables table.
*
* @author Dennis M. Sosnoski
*/
public class ContextMethodBuilder extends ExceptionMethodBuilder
{
/** Variable slot for current object reference. */
private int m_objectSlot;
/** Object type as accessed by method (null if none). */
private String m_objectType;
/** Variable slot for context reference. */
private int m_contextSlot;
/** Context type as accessed by method. */
private String m_contextType;
/** Context type as accessed by method. */
private final boolean m_isStatic;
/**
* Constructor with types specified. This sets up for constructing a
* binding method that uses a current object and a marshalling or
* unmarshalling context.
*
* @param name method name to be built
* @param ret method return type
* @param args types of arguments
* @param cf owning class file information
* @param access flags for method access
* @param obj variable slot for current object (negative value if to be
* defined later)
* @param type current object type as defined in method (null
* if none)
* @param ctx variable slot for marshalling/unmarshalling context
* @param ctype context type as defined in method
*/
public ContextMethodBuilder(String name, Type ret, Type[] args,
ClassFile cf, int access, int obj, String type, int ctx, String ctype) {
super(name, ret, args, cf, access);
m_objectSlot = obj;
m_objectType = type;
m_contextSlot = ctx;
m_contextType = ctype;
m_isStatic = (access & Constants.ACC_STATIC) != 0;
addException(FRAMEWORK_EXCEPTION_CLASS);
}
/**
* Constructor from signature.
*
* @param name method name to be built
* @param sig method signature
* @param cf owning class file information
* @param access flags for method access
* @param obj variable slot for current object (negative value if to be
* defined later)
* @param type current object type
* @param ctx variable slot for marshalling/unmarshalling context
* @param ctype context type as defined in method
*/
public ContextMethodBuilder(String name, String sig,
ClassFile cf, int access, int obj, String type, int ctx, String ctype) {
this(name, Type.getReturnType(sig), Type.getArgumentTypes(sig),
cf, access, obj, type, ctx, ctype);
}
/**
* Constructor from signature for public, final method.
*
* @param name method name to be built
* @param sig method signature
* @param cf owning class file information
* @param obj variable slot for current object (negative value if to be
* defined later)
* @param type current object type
* @param ctx variable slot for marshalling/unmarshalling context
* @param ctype context type as defined in method
*/
public ContextMethodBuilder(String name, String sig, ClassFile cf,
int obj, String type, int ctx, String ctype) {
this(name, sig, cf, Constants.ACC_PUBLIC|Constants.ACC_FINAL,
obj, type, ctx, ctype);
}
/**
* Set current object slot. Sets the local variable position of the current
* object, as required when the object is actually created within the
* method.
*
* @param slot local variable slot for current object
*/
public void setObjectSlot(int slot) {
m_objectSlot = slot;
}
/**
* Append instruction to load object to stack.
*/
public void loadObject() {
if (m_objectType == null) {
throw new IllegalStateException("Internal error - no object type");
} else {
appendLoadLocal(m_objectSlot);
}
}
/**
* Append instruction to store object from stack.
*/
public void storeObject() {
if (m_objectType == null) {
throw new IllegalStateException("Internal error - no object type");
} else {
if (m_objectSlot < 0) {
LocalVariableGen var = createLocal("obj",
ClassItem.typeFromName(m_objectType));
m_objectSlot = var.getIndex();
} else {
appendCreateCast(m_objectType);
appendStoreLocal(m_objectSlot);
}
}
}
/**
* Append instruction(s) to load object to stack as specified type.
*
* @param type loaded type expected on stack
*/
public void loadObject(String type) {
if (m_objectType == null) {
throw new IllegalStateException("Internal error - no object type");
} else {
appendLoadLocal(m_objectSlot);
if (!m_objectType.equals(type)) {
appendCreateCast(m_objectType, type);
}
}
}
/**
* Append instruction to load context to stack.
*/
public void loadContext() {
appendLoadLocal(m_contextSlot);
}
/**
* Append instruction(s) to load context to stack as specified type.
*
* @param type loaded type expected on stack
*/
public void loadContext(String type) {
appendLoadLocal(m_contextSlot);
if (!m_contextType.equals(type)) {
appendCreateCast(m_contextType, type);
}
}
/**
* Check if method is static.
*
* @return true if static, false if not
*/
public boolean isStaticMethod() {
return m_isStatic;
}
/**
* Construct fully-qualified class and method name for method under
* construction.
*
* @return fully-qualified class and method name
*/
public String getFullName() {
return getClassFile().getName() + '.' + getName();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/classes/InstructionBuilder.java 0000644 0001750 0001750 00000022540 10263161056 027414 0 ustar twerner twerner /*
Copyright (c) 2003, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.binding.classes;
import java.security.InvalidParameterException;
import org.apache.bcel.Constants;
import org.apache.bcel.generic.*;
/**
* Instruction builder. Extends the basic instruction construction tools in
* BCEL with some convenience methods.
*
* @author Dennis M. Sosnoski
* @version 1.0
*/
public class InstructionBuilder extends InstructionFactory
{
/**
* Constructor.
*
* @param cg class generation information
* @param cp constant pool generator
*/
public InstructionBuilder(ClassGen cg, ConstantPoolGen cp) {
super(cg, cp);
}
/**
* Get constant pool generator.
*
* @return constant pool generator for class
*/
public ConstantPoolGen getConstantPoolGen() {
return cp;
}
/**
* Create load constant instruction. Builds the most appropriate type of
* instruction for the value.
*
* @param value constant value to be loaded
* @return generated instruction information
*/
public CompoundInstruction createLoadConstant(int value) {
return new PUSH(cp, value);
}
/**
* Create load constant instruction. Loads a String reference
* from the constant pool.
*
* @param value constant value to be loaded
* @return generated instruction information
*/
public CompoundInstruction createLoadConstant(String value) {
return new PUSH(cp, value);
}
/**
* Create load constant instruction. Loads an unwrapped primitive value or
* String from the constant pool.
*
* @param value constant value to be loaded
* @return generated instruction information
*/
public CompoundInstruction createLoadConstant(Object value) {
if (value instanceof Boolean) {
return new PUSH(cp, (Boolean)value);
} else if (value instanceof Character) {
return new PUSH(cp, (Character)value);
} else if (value instanceof Number) {
return new PUSH(cp, (Number)value);
} else if (value instanceof String) {
return new PUSH(cp, (String)value);
} else {
throw new InvalidParameterException
("Internal code generation error!");
}
}
/**
* Create getfield instruction. Uses the field information to generate
* the instruction.
*
* @param item information for field to be set
* @return generated instruction information
*/
public FieldInstruction createGetField(ClassItem item) {
String cname = item.getClassFile().getName();
String fname = item.getName();
return new GETFIELD(cp.addFieldref(cname, fname, item.getSignature()));
}
/**
* Create putfield instruction. Uses the field information to generate
* the instruction.
*
* @param item information for field to be set
* @return generated instruction information
*/
public FieldInstruction createPutField(ClassItem item) {
String cname = item.getClassFile().getName();
String fname = item.getName();
return new PUTFIELD(cp.addFieldref(cname, fname, item.getSignature()));
}
/**
* Create getstatic instruction. Uses the field information to generate
* the instruction.
*
* @param item information for field to be set
* @return generated instruction information
*/
public FieldInstruction createGetStatic(ClassItem item) {
String cname = item.getClassFile().getName();
String fname = item.getName();
return new GETSTATIC(cp.addFieldref(cname, fname, item.getSignature()));
}
/**
* Create putstatic instruction. Uses the field information to generate
* the instruction.
*
* @param item information for field to be set
* @return generated instruction information
*/
public FieldInstruction createPutStatic(ClassItem item) {
String cname = item.getClassFile().getName();
String fname = item.getName();
return new PUTSTATIC(cp.addFieldref(cname, fname, item.getSignature()));
}
/**
* Create invoke instruction for static method. Uses the method information
* to generate the instruction.
*
* @param item information for method to be called
* @return generated instruction information
*/
public InvokeInstruction createCallStatic(ClassItem item) {
String cname = item.getClassFile().getName();
String mname = item.getName();
int index = cp.addMethodref(cname, mname, item.getSignature());
return new INVOKESTATIC(index);
}
/**
* Create invoke instruction for virtual method. Uses the method information
* to generate the instruction.
*
* @param item information for method to be called
* @return generated instruction information
*/
public InvokeInstruction createCallVirtual(ClassItem item) {
String cname = item.getClassFile().getName();
String mname = item.getName();
int index = cp.addMethodref(cname, mname, item.getSignature());
return new INVOKEVIRTUAL(index);
}
/**
* Create invoke instruction for interface method. Uses the method
* information to generate the instruction.
*
* @param item information for method to be called
* @return generated instruction information
*/
public InvokeInstruction createCallInterface(ClassItem item) {
String cname = item.getClassFile().getName();
String mname = item.getName();
String signature = item.getSignature();
return createInvoke(cname, mname, Type.getReturnType(signature),
Type.getArgumentTypes(signature), Constants.INVOKEINTERFACE);
}
/**
* Create invoke static method instruction from signature.
*
* @param method fully qualified class and method name
* @param signature method signature in standard form
* @return generated instruction information
*/
public InvokeInstruction createCallStatic(String method, String signature) {
int split = method.lastIndexOf('.');
String cname = method.substring(0, split);
String mname = method.substring(split+1);
int index = cp.addMethodref(cname, mname, signature);
return new INVOKESTATIC(index);
}
/**
* Create invoke virtual method instruction from signature.
*
* @param method fully qualified class and method name
* @param signature method signature in standard form
* @return generated instruction information
*/
public InvokeInstruction createCallVirtual(String method,
String signature) {
int split = method.lastIndexOf('.');
String cname = method.substring(0, split);
String mname = method.substring(split+1);
int index = cp.addMethodref(cname, mname, signature);
return new INVOKEVIRTUAL(index);
}
/**
* Create invoke interface method instruction from signature.
*
* @param method fully qualified interface and method name
* @param signature method signature in standard form
* @return generated instruction information
*/
public InvokeInstruction createCallInterface(String method,
String signature) {
int split = method.lastIndexOf('.');
String cname = method.substring(0, split);
String mname = method.substring(split+1);
return createInvoke(cname, mname, Type.getReturnType(signature),
Type.getArgumentTypes(signature), Constants.INVOKEINTERFACE);
}
/**
* Create invoke initializer instruction from signature.
*
* @param name fully qualified class name
* @param signature method signature in standard form
* @return generated instruction information
*/
public InvokeInstruction createCallInit(String name, String signature) {
int index = cp.addMethodref(name, "", signature);
return new INVOKESPECIAL(index);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/generator/ 0000755 0001750 0001750 00000000000 11526304016 023245 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/binding/generator/BindGenCommandLine.java 0000644 0001750 0001750 00000015155 11157776412 027551 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.binding.generator;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Map;
import org.jibx.custom.classes.GlobalCustom;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IUnmarshallable;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.generator.SchemaGenCommandLine;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.IClassLocator;
import org.jibx.util.ReflectionUtilities;
/**
* Command line processing specifically for the {@link BindGen} class.
*
* @author Dennis M. Sosnoski
*/
public class BindGenCommandLine extends SchemaGenCommandLine
{
/** Ordered array of extra usage lines. */
private static final String[] EXTRA_USAGE_LINES =
new String[] { " -a force abstract mappings for specified classes",
" -b name generated root binding name (default is 'binding.xml')",
" -m force concrete mappings for specified classes",
" -o binding generation only flag, skip schema generation" };
/**
* TRUE if abstract mappings forced, FALSE if concrete mappings forced,
* null if left to class settings.
*/
private Boolean m_abstract;
/** Customizations model root. */
private GlobalCustom m_global;
/** Name used for root binding. */
private String m_bindingName = "binding.xml";
/** Binding generation only flag (skip schema generation). */
private boolean m_bindingOnly;
/**
* Constructor.
*/
public BindGenCommandLine() {
super(EXTRA_USAGE_LINES);
}
/**
* Get force abstract mapping setting.
*
* @return TRUE if abstract mappings forced, FALSE if concrete mappings forced,
* null if left to class settings
*/
public Boolean getAbstract() {
return m_abstract;
}
/**
* Get customizations model root.
*
* @return customizations
*/
public GlobalCustom getGlobal() {
return m_global;
}
/**
* Get binding name.
*
* @return name
*/
public String getBindingName() {
return m_bindingName;
}
/**
* Check if only binding generation to be done.
*
* @return true if only binding generation, false if both binding and schema
*/
public boolean isBindingOnly() {
return m_bindingOnly;
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.CustomizationCommandLineBase#checkParameter(org.jibx.binding.generator.CustomizationCommandLineBase.ArgList)
*/
protected boolean checkParameter(ArgList alist) {
boolean match = true;
String arg = alist.current();
if ("-a".equalsIgnoreCase(arg)) {
m_abstract = Boolean.TRUE;
} else if ("-b".equalsIgnoreCase(arg)) {
m_bindingName = alist.next();
} else if ("-m".equalsIgnoreCase(arg)) {
m_abstract = Boolean.FALSE;
} else if ("-o".equalsIgnoreCase(arg)) {
m_bindingOnly = true;
} else {
match = super.checkParameter(alist);
}
return match;
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.ClassCustomizationBase#loadCustomizations(String,IClassLocator.ValidationContext)
*/
protected void loadCustomizations(String path, IClassLocator loc, ValidationContext vctx) throws JiBXException, IOException {
// load or create customization information
setLocator(loc);
m_global = new GlobalCustom(loc);
if (path != null) {
IBindingFactory fact = BindingDirectory.getFactory("class_customs_binding", GlobalCustom.class);
IUnmarshallingContext ictx = fact.createUnmarshallingContext();
FileInputStream is = new FileInputStream(path);
ictx.setDocument(is, null);
ictx.setUserContext(vctx);
((IUnmarshallable)m_global).unmarshal(ictx);
}
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.CustomizationCommandLineBase#applyOverrides(Map)
*/
protected Map applyOverrides(Map overmap) {
Map unknowns = ReflectionUtilities.applyKeyValueMap(overmap, m_global);
m_global.initClasses();
m_global.fillClasses();
return unknowns;
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.CustomizationCommandLineBase#printUsage()
*/
public void printUsage() {
System.out.println("\nUsage: java org.jibx.binding.generator.BindGen "
+ "[options] class1 class2 ...\nwhere options are:");
String[] usages = getUsageLines();
for (int i = 0; i < usages.length; i++) {
System.out.println(usages[i]);
}
System.out.println("The class# files are different classes to be included in the binding (references\n" +
"from these classes will also be included).\n");
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/generator/BindingMappingDetail.java 0000644 0001750 0001750 00000021760 11027507160 030130 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.binding.generator;
import java.util.Map;
import org.jibx.binding.model.MappingElement;
import org.jibx.binding.model.MappingElementBase;
import org.jibx.runtime.QName;
/**
* Holder for the details of how a class is going to be mapped. This information is needed in order to determine how to
* reference the mapped class when it's used within another mapping definition.
*
* @author Dennis M. Sosnoski
*/
public class BindingMappingDetail
{
/** Fully-qualified class name of mapped class. */
private final String m_type;
/** Generate abstract mapping flag. */
private boolean m_useAbstract;
/** Generate concrete mapping flag. */
private boolean m_useConcrete;
/** Flag for class extended by other mapped class(es). */
private boolean m_isExtended;
/** Abstract mapping type name (null if none). */
private final QName m_typeQName;
/** Concrete mapping element name (null if none). */
private QName m_elementQName;
/** Concrete mapping type extended by this one. */
private String m_extendsType;
/** Map from access method name to property customization information for properties covered by this mapping
(including inherited ones). */
private Map m_propertyMethodMap;
/** Flag for mapping(s) has been generated. */
private boolean m_isGenerated;
/** Abstract mapping definition (null if none). */
private MappingElement m_abstractMapping;
/** Concrete mapping definition (null if none). */
private MappingElementBase m_concreteMapping;
/**
* Constructor.
*
* @param type fully-qualified mapped class name
* @param aname abstract mapping type name
* @param cname concrete mapping element name
* @param stype superclass for extension (null if not an extension mapping)
*/
protected BindingMappingDetail(String type, QName aname, QName cname, String stype) {
m_type = type;
m_typeQName = aname;
m_elementQName = cname;
m_extendsType = stype;
}
/**
* Get fully-qualified name of mapped class.
*
* @return class name
*/
public String getType() {
return m_type;
}
/**
* Get the abstract <mapping> for the target class.
*
* @return abstract , null if none
*/
public MappingElement getAbstractMapping() {
return m_abstractMapping;
}
/**
* Set the abstract <mapping> for the target class.
*
* @param abs abstract , null if none
*/
public void setAbstractMapping(MappingElement abs) {
m_abstractMapping = abs;
}
/**
* Get the concrete <mapping> for the target class.
*
* @return concrete , null if none
*/
public MappingElementBase getConcreteMapping() {
return m_concreteMapping;
}
/**
* Set the concrete <mapping> for the target class.
*
* @param con concrete , null if none
*/
public void setConcreteMapping(MappingElementBase con) {
m_concreteMapping = con;
}
/**
* Check for target class extended by other mapped class(es).
*
* @return true if extended, false if not
*/
public boolean isExtended() {
return m_isExtended;
}
/**
* Set target class extended by other mapped class(es). Setting this true forces a concrete
* <mapping> to be used.
*
* @param ext
*/
public void setExtended(boolean ext) {
m_isExtended = ext;
if (ext) {
setUseConcrete(true);
}
}
/**
* Check if this <mapping> has been generated.
*
* @return true if generated, false if not
*/
public boolean isGenerated() {
return m_isGenerated;
}
/**
* Set flag for <mapping> generated.
*
* @param gen
*/
public void setGenerated(boolean gen) {
m_isGenerated = gen;
}
/**
* Check if an abstract <mapping> used for this class.
*
* @return true if abstract mapping used, false if not
*/
public boolean isUseAbstract() {
return m_useAbstract;
}
/**
* Set flag for abstract <mapping> used for this class.
*
* @param abs true if abstract mapping used, false if not
*/
public void setUseAbstract(boolean abs) {
m_useAbstract = abs;
}
/**
* Check if a concrete <mapping> used for this class.
*
* @return true if concrete mapping used, false if not
*/
public boolean isUseConcrete() {
return m_useConcrete;
}
/**
* Set flag for concrete <mapping> used for this class.
*
* @param con true if concrete mapping used, false if not
*/
public void setUseConcrete(boolean con) {
m_useConcrete = con;
if (!con && m_isExtended) {
throw new IllegalStateException("Internal error - concrete must be used for extensions");
}
}
/**
* Get the element name used for a concrete mapping. Note that this method will always return a
* non-null result if a concrete mapping is being used, but may also return a non-null
* result even if there is no concrete mapping - so check first using the {@link #isUseConcrete()} method.
*
* @return element name, or null if not defined
*/
public QName getElementQName() {
return m_elementQName;
}
/**
* Set the element name used for a concrete mapping.
*
* @param qname element name, or null if not defined
*/
public void setElementQName(QName qname) {
m_elementQName = qname;
}
/**
* Get the fully-qualified class name of the type extended by this <mapping>.
*
* @return class name, or null if none
*/
public String getExtendsType() {
return m_extendsType;
}
/**
* Get the type name used for an abstract mapping. Note that this method will always return a non-null
* result if an abstract mapping is being used, but may also return a non-null result even if there is
* no abstract mapping - so check first using the {@link #isUseConcrete()} method.
*
* @return type name, or null if not defined
*/
public QName getTypeQName() {
return m_typeQName;
}
/**
* Get map from access method name to property customization information for properties covered by this
* <mapping>. This map includes both properties defined directly, and those inherited from any base mapping.
*
* @return map (non-null after <mapping> constructed)
*/
public Map getAccessMethodMap() {
return m_propertyMethodMap;
}
/**
* Set map from access method name to property customization information for properties covered by this
* <mapping>. This must be done at the time the <mapping> is constructed.
*
* @param map (non-null, use empty map if not applicable)
*/
public void setAccessMethodMap(Map map) {
m_propertyMethodMap = map;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/generator/BindGen.java 0000644 0001750 0001750 00000156102 11414106022 025414 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.binding.generator;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.jibx.binding.model.BindingElement;
import org.jibx.binding.model.BindingHolder;
import org.jibx.binding.model.BindingOrganizer;
import org.jibx.binding.model.CollectionElement;
import org.jibx.binding.model.ElementBase;
import org.jibx.binding.model.FormatElement;
import org.jibx.binding.model.MappingElement;
import org.jibx.binding.model.MappingElementBase;
import org.jibx.binding.model.NestingElementBase;
import org.jibx.binding.model.StructureElement;
import org.jibx.binding.model.StructureElementBase;
import org.jibx.binding.model.ValidationContext;
import org.jibx.binding.model.ValueElement;
import org.jibx.custom.classes.ClassCustom;
import org.jibx.custom.classes.GlobalCustom;
import org.jibx.custom.classes.ValueCustom;
import org.jibx.custom.classes.NestingBase;
import org.jibx.custom.classes.PackageCustom;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.runtime.Utility;
import org.jibx.schema.generator.SchemaGen;
import org.jibx.util.IClass;
import org.jibx.util.IClassLocator;
import org.jibx.util.ReferenceCountMap;
import org.jibx.util.Types;
import org.jibx.util.UniqueNameSet;
/**
* Binding generator implementation. Although many of the methods in this class use public access, they are
* intended for use only by the JiBX developers and may change from one release to the next. To make use of this class
* from your own code, call the {@link #main(String[])} method with an appropriate argument list.
*
* @author Dennis M. Sosnoski
*/
public class BindGen
{
/** Binding generation customizations. */
private final GlobalCustom m_global;
/** Set of class names to be included. */
private final Set m_includeSet;
/** Set of class names to be ignored. */
private final Set m_ignoreSet;
/** Set of class names to be handled directly. */
private final Set m_directSet;
/** Set of class names subclassed by other classes in binding. */
private final Set m_superSet;
/** Set of class names possibly requiring format definitions. */
private final Set m_formatSet;
/** Map from fully-qualified class name to mapping details. */
private final Map m_mappingDetailsMap;
/** Map from namespace URI to {@link UniqueNameSet} for type names. */
private final Map m_typeNamesMap;
/** Map from namespace URI to {@link UniqueNameSet} for element names. */
private final Map m_elementNamesMap;
/** Target package for binding code generation. */
private String m_targetPackage;
/** Directory for bindings being built. */
private BindingOrganizer m_directory;
/**
* Create a generator based on a particular set of customizations.
*
* @param glob
*/
public BindGen(GlobalCustom glob) {
m_global = glob;
m_includeSet = new HashSet();
m_ignoreSet = new HashSet();
m_directSet = new HashSet();
m_superSet = new HashSet();
m_formatSet = new HashSet();
m_mappingDetailsMap = new HashMap();
m_typeNamesMap = new HashMap();
m_elementNamesMap = new HashMap();
m_directory = new BindingOrganizer(glob.isForceClasses(), glob.isTrackSource(), glob.isAddConstructors(),
glob.isInput(), glob.isOutput(), false);
}
/**
* Check if a class represents a simple value. TODO: implement ClassCustom hooks for this purpose
*
* @param type fully qualified class name
* @return true if simple value, false if not
*/
public boolean isValueClass(String type) {
ClassCustom clas = m_global.addClassCustomization(type);
if (clas.isSimpleValue()) {
m_formatSet.add(type);
return true;
}
IClass sinfo = clas.getClassInformation().getSuperClass();
if (sinfo != null && "java.lang.Enum".equals(sinfo.getName())) {
return true;
} else {
return false;
}
}
/**
* Check if a class needs to be included in the binding. This checks all members of the class and if necessary
* superclasses, returning true if any member is ultimately found with a simple value.
*
* @param type fully qualified class name
* @return true if class to be included in binding, false if it should be skipped
*/
public boolean checkInclude(String type) {
if (m_includeSet.contains(type)) {
return true;
} else if (m_ignoreSet.contains(type)) {
return false;
} else {
// check if any members are to be included
boolean include = false;
ClassCustom clas = m_global.addClassCustomization(type);
if (clas.isSimpleValue()) {
include = true;
} else {
// check each member to find anything to be included
for (Iterator iter = clas.getMembers().iterator(); iter.hasNext();) {
ValueCustom memb = (ValueCustom)iter.next();
String mtype = memb.isCollection() ? memb.getItemType() : memb.getWorkingType();
if (Types.isSimpleValue(mtype) || isValueClass(mtype) || !m_global.isKnownMapping(mtype)
|| checkInclude(mtype)) {
include = true;
break;
}
}
}
if (!include) {
// force superclass handling if appropriate
if (clas.getMembers().size() > 0 && clas.isUseSuper()) {
String stype = clas.getClassInformation().getSuperClass().getName();
if (!"java.lang.Object".equals(stype) && checkInclude(stype)) {
include = true;
}
}
}
if (include) {
m_includeSet.add(type);
} else {
m_ignoreSet.add(type);
}
return include;
}
}
/**
* Expand all references from a class. This checks the types of all members of the class, counting references and
* calling itself recursively for any types which are not primitives and not java.* or javax.* classes. It also
* expands the superclass, if specified by the class customizations.
*
* @param type fully qualified class name
* @param refmap reference count map
*/
public void expandReferences(String type, ReferenceCountMap refmap) {
if (checkInclude(type)) {
// skip any member processing if a simple value
ClassCustom clas = m_global.addClassCustomization(type);
if (clas.isSimpleValue()) {
return;
}
// increment reference count if forced mapping requested for class
if (clas.isForceMapping() || clas.isAbstractMappingForced() || clas.isConcreteMappingForced()) {
refmap.incrementCount(type);
}
// expand all references from members
for (Iterator iter = clas.getMembers().iterator(); iter.hasNext();) {
ValueCustom memb = (ValueCustom)iter.next();
String mtype = memb.isCollection() ? memb.getItemType() : memb.getWorkingType();
if (!Types.isSimpleValue(mtype) && !isValueClass(mtype) && !m_global.isKnownMapping(mtype)) {
if ((mtype.startsWith("java.")) || (mtype.startsWith("javax."))) {
throw new IllegalStateException("No way to handle type " + mtype + ", referenced from " + type);
} else if (checkInclude(mtype)) {
if (refmap.incrementCount(mtype) <= 1) {
expandReferences(mtype, refmap);
}
m_directSet.add(mtype);
}
}
}
// force superclass handling if appropriate
if (clas.getMembers().size() > 0 && clas.isUseSuper()) {
String stype = clas.getClassInformation().getSuperClass().getName();
if (!"java.lang.Object".equals(stype) && !Types.isSimpleValue(stype) && !isValueClass(stype)
&& !m_global.isKnownMapping(stype) && checkInclude(stype)) {
if (refmap.incrementCount(stype) <= 1) {
expandReferences(stype, refmap);
}
m_superSet.add(stype);
}
}
}
}
/**
* Set creation information for structure binding component. This includes the declared type, as well as the create
* type and factory method.
*
* @param memb
* @param struct
*/
private void setTypes(ValueCustom memb, StructureElementBase struct) {
String type = memb.getActualType();
if (type != null && !type.equals(memb.getStatedType())) {
struct.setDeclaredType(type);
}
struct.setCreateType(memb.getCreateType());
struct.setFactoryName(memb.getFactoryMethod());
}
/**
* Define the details of a collection binding. Collection bindings may be empty (in the case where the item type is
* directly mapped), have a <value> child element, or have either a mapping reference or direct definition
* <structure> child element. This determines the appropriate form based on the item type.
*
* @param itype item type
* @param iname item name
* @param coll
* @param hold
*/
public void defineCollection(String itype, String iname, CollectionElement coll, BindingHolder hold) {
// check item type handling
BindingMappingDetail detail = (BindingMappingDetail)m_mappingDetailsMap.get(itype);
ClassCustom custom = m_global.getClassCustomization(itype);
if (detail != null) {
if (detail.isUseAbstract() && !detail.isExtended()) {
// add with map-as for abstract mapping
QName qname = detail.getTypeQName();
if (iname == null) {
iname = custom.getElementName();
}
StructureElement struct = new StructureElement();
if (qname == null) {
struct.setMapAsName(itype);
} else {
// set the type reference and namespace dependency
String uri = qname.getUri();
hold.addTypeNameReference(uri, uri);
struct.setMapAsQName(qname);
}
struct.setName(iname);
hold.addNamespaceUsage(hold.getNamespace());
struct.setCreateType(custom.getCreateType());
struct.setFactoryName(custom.getFactoryMethod());
coll.addChild(struct);
} else {
// just set item-type for concrete mapping
coll.setItemTypeName(itype);
}
} else if (m_global.isKnownMapping(itype)) {
// just set item-type for known mapping
coll.setItemTypeName(itype);
} else if (Types.isSimpleValue(itype) || isValueClass(itype)) {
// add for simple type, or enum type with optional value method
ValueElement value = new ValueElement();
value.setName(iname);
value.setDeclaredType(itype);
coll.addChild(value);
if (custom != null) {
value.setDefaultText(custom.getEnumValueMethod());
}
} else {
// embed structure definition within the collection
StructureElement struct = new StructureElement();
struct.setDeclaredType(itype);
if (iname == null) {
iname = custom.getElementName();
}
struct.setName(iname);
hold.addNamespaceUsage(hold.getNamespace());
fillStructure(custom, null, null, struct, hold);
coll.addChild(struct);
}
}
/**
* Add binding details for the actual members of a class, excluding any members which have been handled separately.
*
* @param cust class customization information
* @param exmethmap map from property method names to be excluded to the corresponding property customizations
* @param inmethmap map from property method names included in binding to the corresponding property customizations
* (populated by this method, null if not needed)
* @param parent containing binding component
* @param hold binding holder
*/
private void addMemberBindings(ClassCustom cust, Map exmethmap, Map inmethmap, NestingElementBase parent,
BindingHolder hold) {
// generate binding component for each member of class
for (Iterator iter = cust.getMembers().iterator(); iter.hasNext();) {
// skip this member if excluded property
ValueCustom memb = (ValueCustom)iter.next();
String gmeth = memb.getGetName();
String smeth = memb.getSetName();
if (memb.isProperty() && !memb.isPrivate()) {
ValueCustom match = (ValueCustom)(gmeth != null ? exmethmap.get(gmeth) : exmethmap.get(smeth));
if (match == null) {
// add methods for included property to map implemented for this binding
if (inmethmap != null) {
if (gmeth != null) {
inmethmap.put(gmeth, memb);
}
if (smeth != null) {
inmethmap.put(smeth, memb);
}
}
} else {
continue;
}
}
// check for repeated item
if (memb.isCollection()) {
// create collection element for field or property
CollectionElement coll = new CollectionElement();
if (memb.getFieldName() == null) {
coll.setGetName(gmeth);
coll.setSetName(memb.getSetName());
} else {
coll.setFieldName(memb.getFieldName());
}
setTypes(memb, coll);
// set the element name, if defined
String name = memb.getXmlName();
if ((cust.isWrapCollections() || memb.isElementForced()) && name != null) {
coll.setName(name);
hold.addNamespaceUsage(hold.getNamespace());
}
// check for optional value
if (!memb.isRequired()) {
coll.setUsageName("optional");
}
// check for type defined
String itype = memb.getItemType();
if (itype != null) {
// set name to be used for items in collection
String iname = memb.getItemName();
if (iname == null) {
// use name based on item type
String simple = itype;
int split = simple.lastIndexOf('.');
if (split >= 0) {
simple = simple.substring(0, split);
}
iname = cust.convertName(simple);
}
// define the collection details
defineCollection(itype, iname, coll, hold);
// check for special case of two unwrapped collections with same item-type and no children
ArrayList siblings = parent.children();
if (siblings.size() > 0 && coll.children().size() == 0 && coll.getName() == null) {
ElementBase sibling = (ElementBase)siblings.get(siblings.size()-1);
if (sibling.type() == ElementBase.COLLECTION_ELEMENT) {
CollectionElement lastcoll = (CollectionElement)sibling;
if (lastcoll.children().size() == 0 && lastcoll.getName() == null &&
Utility.safeEquals(lastcoll.getItemTypeName(), coll.getItemTypeName())) {
throw new IllegalStateException("Need to use wrapper element for collection member '" +
memb.getBaseName() + "' of class " + cust.getName());
}
}
}
}
parent.addChild(coll);
} else {
// check whether value or structure
String wtype = memb.getWorkingType();
if (Types.isSimpleValue(wtype) || isValueClass(wtype)) {
// add for simple type or enum
ValueElement value = new ValueElement();
if (memb.getFieldName() == null) {
value.setGetName(gmeth);
value.setSetName(memb.getSetName());
} else {
value.setFieldName(memb.getFieldName());
}
value.setName(memb.getXmlName());
hold.addNamespaceUsage(hold.getNamespace());
// pass on optional value method for enum
ClassCustom icust = m_global.getClassCustomization(wtype);
if (icust != null) {
value.setEnumValueName(icust.getEnumValueMethod());
}
// check for optional value
if (!memb.isRequired()) {
value.setUsageName("optional");
}
// configure added property values
int style = memb.getStyle();
if (style == NestingBase.ATTRIBUTE_VALUE_STYLE) {
value.setStyleName("attribute");
} else if (style == NestingBase.ELEMENT_VALUE_STYLE) {
value.setStyleName("element");
} else {
value.setStyleName("text");
value.setName(null);
}
if (memb.getActualType() != null) {
value.setDeclaredType(memb.getActualType());
}
parent.addChild(value);
} else {
// create with name and access information
StructureElement struct = new StructureElement();
if (memb.getFieldName() == null) {
struct.setGetName(gmeth);
struct.setSetName(memb.getSetName());
} else {
struct.setFieldName(memb.getFieldName());
}
setTypes(memb, struct);
// check for optional value
if (!memb.isRequired()) {
struct.setUsageName("optional");
}
// set details based on class handling
ClassCustom mcust = m_global.getClassCustomization(memb.getWorkingType());
fillStructure(mcust, memb, null, struct, hold);
parent.addChild(struct);
}
}
}
}
/**
* Add binding details for the full representation of a class. This includes superclasses, if configured, and makes
* use of any appropriate <mapping> definitions as part of the binding.
*
* @param cust class customization information
* @param memb member customization information (null if implicit reference, rather than member)
* @param inmethmap map from property method names included in binding to the corresponding property customizations,
* (needed in case of interface or overridden methods; populated by this method, null if not needed)
* @param struct structure element referencing the class
* @param hold binding holder
*/
private void fillStructure(ClassCustom cust, ValueCustom memb, Map inmethmap, StructureElement struct,
BindingHolder hold) {
// check for an actual definition
String type = cust.getName();
BindingMappingDetail detail = (BindingMappingDetail)m_mappingDetailsMap.get(type);
if (detail != null) {
// use existing definition for type
if (detail.isUseAbstract() && !detail.isExtended()) {
QName qname = detail.getTypeQName();
String uri = qname.getUri();
hold.addTypeNameReference(uri, uri);
struct.setMapAsQName(qname);
if (memb != null) {
struct.setName(memb.getXmlName());
hold.addNamespaceUsage(hold.getNamespace());
}
} else {
struct.setMapAsName(cust.getName());
}
if (inmethmap != null) {
inmethmap.putAll(detail.getAccessMethodMap());
}
} else if (!m_global.isKnownMapping(type)) {
// add member reference information
if (memb != null) {
// check for type settings needed
if (memb.getActualType() != null) {
struct.setDeclaredType(memb.getActualType());
}
if (memb.getCreateType() != null) {
struct.setCreateType(memb.getCreateType());
}
if (memb.getFactoryMethod() != null) {
struct.setFactoryName(memb.getFactoryMethod());
}
// add a name if an optional value
if (cust.isForceStructureNames() || !memb.isRequired()) {
struct.setName(memb.getXmlName());
hold.addNamespaceUsage(hold.getNamespace());
}
}
// check if need to use superclass in binding
IClass clas = cust.getClassInformation();
IClass sclas = clas.getSuperClass();
String stype = sclas.getName();
Map exmethmap = Collections.EMPTY_MAP;
if (checkInclude(stype)) {
// check if any added content from this class
ClassCustom scust = m_global.getClassCustomization(stype);
exmethmap = new HashMap();
if (cust.getMembers().size() > 0) {
// add child element for superclass, followed by content from this class
StructureElement sstruct = new StructureElement();
sstruct.setDeclaredType(stype);
fillStructure(scust, null, exmethmap, sstruct, hold);
struct.addChild(sstruct);
} else {
// just replace class reference with superclass reference in existing
struct.setDeclaredType(stype);
fillStructure(scust, null, exmethmap, struct, hold);
}
} else {
// check for interface with abstract mapping to reference
String[] intfs = sclas.getInterfaces();
for (int i = 0; i < intfs.length; i++) {
String intf = intfs[i];
BindingMappingDetail idetail = (BindingMappingDetail)m_mappingDetailsMap.get(intf);
if (idetail != null && idetail.isUseAbstract() && idetail.getTypeQName() == null) {
// reference abstract mapped interface
struct = new StructureElement();
struct.setMapAsName(intf);
exmethmap = idetail.getAccessMethodMap();
break;
}
}
}
// fill in content details from this class
if (inmethmap != null) {
inmethmap.putAll(exmethmap);
}
if (cust.getMembers().size() > 0) {
addMemberBindings(cust, exmethmap, inmethmap, struct, hold);
}
}
}
/**
* Add the <mapping> definition for a class to a binding. This creates either an abstract mapping with a type
* name, or a concrete mapping with an element name, as determined by the passed-in mapping information. If the
* class is a concrete mapping that extends or implements another class with an anonymous abstract mapping, the
* created <mapping> will extend that base mapping. TODO: type substitution requires extending the binding
* definition
*
* @param type fully qualified class name
* @param detail mapping details
*/
private void addMapping(String type, BindingMappingDetail detail) {
// create the basic mapping structure(s)
ClassCustom cust = m_global.addClassCustomization(type);
MappingElementBase mainmapping = null;
QName qname = null;
MappingElementBase mapcon = null;
IClass clas = cust.getClassInformation();
if (detail.isUseConcrete()) {
// create concrete mapping
mapcon = createMapping(type, cust);
qname = detail.getElementQName();
mapcon.setName(qname.getName());
detail.setConcreteMapping(mapcon);
// make "concrete" mapping abstract if no class creation possible
if (clas.isAbstract() || clas.isInterface()) {
mapcon.setAbstract(true);
}
// fill details directly to this mapping unless abstract also created
mainmapping = mapcon;
}
MappingElement mapabs = null;
if (detail.isUseAbstract()) {
// create abstract mapping
mapabs = createMapping(type, cust);
mapabs.setAbstract(true);
qname = detail.getTypeQName();
mapabs.setTypeQName(qname);
detail.setAbstractMapping(mapabs);
// use abstract mapping for details (concrete will reference this one)
mainmapping = mapabs;
}
if (mainmapping != null) {
// find the binding containing this mapping
String uri = qname.getUri();
BindingHolder hold = m_directory.getBinding(uri);
if (mainmapping.isAbstract()) {
hold.addTypeNameReference(uri, uri);
}
// check for superclass mapping to be extended (do this first for compatibility with schema type extension)
StructureElement struct = null;
String ptype = detail.getExtendsType();
Map exmembmap = Collections.EMPTY_MAP;
Map inmembmap = new HashMap();
if (ptype == null) {
// not extending a base mapping, check if need to include superclass
IClass parent = clas.getSuperClass();
if (cust.isUseSuper() && parent != null) {
ptype = parent.getName();
if (checkInclude(ptype)) {
struct = new StructureElement();
struct.setDeclaredType(ptype);
ClassCustom scust = m_global.getClassCustomization(ptype);
exmembmap = new HashMap();
fillStructure(scust, null, exmembmap, struct, hold);
}
}
} else {
// create reference to parent mapping
struct = new StructureElement();
BindingMappingDetail pdetail = (BindingMappingDetail)m_mappingDetailsMap.get(ptype);
if (!pdetail.isGenerated()) {
addMapping(ptype, pdetail);
}
exmembmap = pdetail.getAccessMethodMap();
if (pdetail.isUseAbstract()) {
// reference abstract mapped superclass
QName tname = pdetail.getTypeQName();
if (tname == null) {
throw new IllegalStateException("Internal error: unimplemented case of superclass " + ptype
+ " to be extended by subclass " + type + ", without an abstract ");
} else {
uri = tname.getUri();
hold.addTypeNameReference(uri, uri);
struct.setMapAsQName(tname);
}
} else {
// reference concrete mapped superclass
struct.setMapAsName(ptype);
}
// set extension for child concrete mapping
if (mapcon != null) {
mapcon.setExtendsName(ptype);
}
}
// add extension reference structure to mapping
if (struct != null) {
mainmapping.addChild(struct);
}
// add all details of class member handling to binding
inmembmap.putAll(exmembmap);
addMemberBindings(cust, exmembmap, inmembmap, mainmapping, hold);
hold.addMapping(mainmapping);
if (mapabs != null && mapcon != null) {
// define content as structure reference to abstract mapping
struct = new StructureElement();
QName tname = detail.getTypeQName();
uri = tname.getUri();
hold.addTypeNameReference(uri, uri);
struct.setMapAsQName(tname);
mapcon.addChild(struct);
hold.addMapping(mapcon);
}
// set the member property map for mapping
detail.setAccessMethodMap(inmembmap);
detail.setGenerated(true);
} else {
throw new IllegalStateException("Internal error: mapping detail for " + type
+ " with neither abstract nor concrete mapping");
}
}
/**
* Create and initialize a <mapping> element.
*
* @param type
* @param cust
* @return mapping
*/
private MappingElement createMapping(String type, ClassCustom cust) {
MappingElement mapabs;
mapabs = new MappingElement();
mapabs.setClassName(type);
mapabs.setCreateType(cust.getCreateType());
mapabs.setFactoryName(cust.getFactoryMethod());
return mapabs;
}
/**
* Add the details for mapping a class.
* TODO: should add checks for unique particle attribution rule - need to check for duplicate element names without
* a required element in between, and if found alter the names after the first; note that duplicates may be from the
* base type, or from a group; also need to make sure attribute names are unique
*
* @param abstr force abstract mapping flag
* @param ename element name for concrete mapping (null if unspecified)
* @param type fully-qualified class name
* @return mapping details
*/
private BindingMappingDetail addMappingDetails(Boolean abstr, QName ename, String type) {
// check for existing detail
BindingMappingDetail detail = (BindingMappingDetail)m_mappingDetailsMap.get(type);
if (detail == null) {
// provide warning when interface used with field access
ClassCustom cust = m_global.getClassCustomization(type);
IClass sclas = cust.getClassInformation();
if (sclas.isInterface() && !cust.isPropertyAccess()) {
System.out.println("Warning: generating mapping for interface " + type +
" without checking properties - consider setting property-access='true'");
}
// check if a superclass is base for extension
String stype = null;
Boolean isabs = null;
while ((sclas = sclas.getSuperClass()) != null) {
if (m_directSet.contains(sclas.getName())) {
stype = sclas.getName();
isabs = Boolean.valueOf(sclas.isAbstract());
break;
}
}
// TODO: really should check for multiple superclasses/interfaces to
// be handled (and generate a warning, since they can't be handled)
if (stype == null) {
// check if an interface is base for extension
sclas = cust.getClassInformation();
loop: while (sclas != null) {
String[] intfs = sclas.getInterfaces();
for (int i = 0; i < intfs.length; i++) {
String itype = intfs[i];
while (true) {
if (m_directSet.contains(itype)) {
stype = itype;
isabs = Boolean.TRUE;
break loop;
} else {
ClassCustom icust = m_global.getClassCustomization(itype);
if (icust == null) {
break;
} else {
// check for interface (should only ever be one) of interface
String[] sintfs = icust.getClassInformation().getInterfaces();
if (sintfs.length > 0) {
itype = sintfs[0];
} else {
break;
}
}
}
}
}
sclas = sclas.getSuperClass();
}
}
if (stype != null) {
BindingMappingDetail sdetail = addMappingDetails(isabs, null, stype);
sdetail.setExtended(true);
}
// force type name to use same namespace as element name, if supplied
QName tname;
if (ename == null) {
tname = cust.getTypeQName();
} else {
tname = new QName(ename.getUri(), cust.getTypeName());
}
// make sure the binding holder has been created for this namespace
String uri = tname.getUri();
if (m_directory.getBinding(uri) == null) {
m_directory.addBinding(uri, uri, null, true);
}
// check or get element name to be used
// TODO: shouldn't need to do this, since element and type in separate namespaces should be allowed
if (isQNameUsed(ename, m_elementNamesMap)) {
throw new IllegalStateException("Internal error - attempting to create mapping with element name " +
ename + " already used");
} else if (ename == null) {
ename = cust.getElementQName();
}
// fix names if necessary to avoid conflicts
tname = fixTypeName(tname);
ename = fixElementName(ename);
// create mapping details as specified
boolean abs = ((abstr == null) ? cust.isMapAbstract() : abstr.booleanValue()) ||
cust.isAbstractMappingForced();
detail = new BindingMappingDetail(type, tname, ename, stype);
if (abs || !cust.isConcreteClass()) {
detail.setUseAbstract(true);
}
// force concrete mapping if not abstract, or if requested, or if extends base or base for extension
if ((!abs || cust.isConcreteMappingForced() || sclas != null || m_superSet.contains(type)
|| (abstr != null && !abstr.booleanValue())) && cust.isConcreteClass()) {
detail.setUseConcrete(true);
}
m_mappingDetailsMap.put(type, detail);
// check if package usable as target for binding code
if (m_targetPackage == null && cust.getClassInformation().isModifiable()) {
m_targetPackage = ((PackageCustom)cust.getParent()).getName();
}
} else if (abstr != null) {
// mapping detail already generated, just make sure of variety
if (abstr.booleanValue()) {
detail.setUseAbstract(true);
} else {
detail.setUseConcrete(true);
}
}
return detail;
}
/**
* Check if a qualified name is already defined within a category of names.
*
* @param qname requested qualified name (null allowed, always returns false)
* @param map namespace URI to {@link UniqueNameSet} map for category
* @return true if used, false if not
*/
private boolean isQNameUsed(QName qname, Map map) {
if (qname != null) {
UniqueNameSet nameset = (UniqueNameSet)map.get(qname.getUri());
if (nameset != null) {
return nameset.contains(qname.getName());
}
}
return false;
}
/**
* Fix local name to be unique within the appropriate namespace for a category of names.
*
* @param qname requested qualified name (null allowed, always returns null)
* @param map namespace URI to {@link UniqueNameSet} map for category
* @return unique version of qualified name
*/
private QName fixQName(QName qname, Map map) {
if (qname != null) {
String uri = qname.getUri();
UniqueNameSet nameset = (UniqueNameSet)map.get(uri);
if (nameset == null) {
nameset = new UniqueNameSet();
map.put(uri, nameset);
}
String base = qname.getName();
String name = nameset.add(base);
if (name.equals(base)) {
return qname;
} else {
return new QName(uri, name);
}
} else {
return null;
}
}
/**
* Fix element local name to be unique within the appropriate namespace.
*
* @param qname requested qualified name (null allowed, always returns null)
* @return unique version of qualified name
*/
private QName fixElementName(QName qname) {
return fixQName(qname, m_elementNamesMap);
}
/**
* Fix type local name to be unique within the appropriate namespace.
*
* @param qname requested qualified name (null allowed, always returns null)
* @return unique version of qualified name
*/
private QName fixTypeName(QName qname) {
return fixQName(qname, m_typeNamesMap);
}
/**
* Find closure of references from a supplied list of classes. References counted, and direct references are
* accumulated for handling. The supplied list may include generic classes with type parameters.
*
* @param classes
* @param refmap
*/
private void findReferences(List classes, ReferenceCountMap refmap) {
for (int i = 0; i < classes.size(); i++) {
String type = (String)classes.get(i);
int split = type.indexOf('<');
if (split > 0) {
type = type.substring(split + 1, type.length() - 1);
}
expandReferences(type, refmap);
}
}
/**
* Flag classes referenced more than once to be handled with <mapping> definitions.
*
* @param refmap
*/
private void flagMultipleReferences(ReferenceCountMap refmap) {
for (Iterator iter = refmap.iterator(); iter.hasNext();) {
String type = (String)iter.next();
if (refmap.getCount(type) > 1) {
m_directSet.add(type);
}
}
}
/**
* Add mapping details for classes referenced more than once, or classes with mapping forced.
*
* @param refmap
*/
private void addReferencedMappings(ReferenceCountMap refmap) {
for (Iterator iter = refmap.iterator(); iter.hasNext();) {
String type = (String)iter.next();
if (refmap.getCount(type) > 1 && !m_mappingDetailsMap.containsKey(type)) {
addMappingDetails(null, null, type);
}
}
}
/**
* Generate the mapping definitions for classes referenced more than once.
*
* @param refmap
*/
private void generateReferencedMappings(ReferenceCountMap refmap) {
for (Iterator iter = refmap.iterator(); iter.hasNext();) {
String type = (String)iter.next();
if (refmap.getCount(type) > 1) {
BindingMappingDetail detail = (BindingMappingDetail)m_mappingDetailsMap.get(type);
if (!detail.isGenerated()) {
addMapping(type, detail);
}
}
}
}
/**
* Generate mappings for a list of classes. The mapping details must have been configured before this method is
* called.
*
* @param classes
*/
private void generateMappings(List classes) {
for (int i = 0; i < classes.size(); i++) {
String type = (String)classes.get(i);
BindingMappingDetail detail = (BindingMappingDetail)m_mappingDetailsMap.get(type);
if (!detail.isGenerated()) {
addMapping(type, detail);
}
}
}
/**
* Fix the base classes that are to be used as extension types. This step is needed to generate the substitution
* group structures for classes which are both referenced directly and extended by other classes. The method must be
* called after all mapping details have been constucted but before the actual binding generation.
*/
private void fixBaseClasses() {
for (Iterator iter = m_directSet.iterator(); iter.hasNext();) {
String type = (String)iter.next();
BindingMappingDetail detail = (BindingMappingDetail)m_mappingDetailsMap.get(type);
if (detail != null && detail.isExtended()) {
detail.setUseConcrete(true);
}
}
}
/**
* Generate any required format definitions. Format definitions are used for all classes defining serializer or
* deserializer methods.
*/
private void generateFormats() {
// add any required format definitions
for (Iterator iter = m_formatSet.iterator(); iter.hasNext();) {
String type = (String)iter.next();
ClassCustom clas = m_global.getClassCustomization(type);
if (clas.getSerializer() != null || clas.getDeserializer() != null) {
FormatElement format = new FormatElement();
format.setDeserializerName(clas.getDeserializer());
format.setSerializerName(clas.getSerializer());
format.setTypeName(type);
m_directory.addFormat(format);
}
}
}
/**
* Generate binding(s) for a list of classes. This creates a <mapping> definition for each class in the list, and
* either embeds <structure> definitions or creates separate <mapping>s for other classes referenced by these
* classes. If all the classes use the same namespace only the binding for that namespace will be created;
* otherwise, a separate binding will be created for each namespace.
*
* @param abstr force abstract mapping flag (use both abstract and concrete if null)
* @param classes class list
*/
public void generate(Boolean abstr, List classes) {
// start by expanding and counting references from supplied classes
ReferenceCountMap refmap = new ReferenceCountMap();
m_directSet.addAll(classes);
findReferences(classes, refmap);
flagMultipleReferences(refmap);
// set the classes to be handled with definitions
for (int i = 0; i < classes.size(); i++) {
BindingMappingDetail detail = addMappingDetails(abstr, null, (String)classes.get(i));
if (abstr == null) {
detail.setUseAbstract(true);
detail.setUseConcrete(true);
}
}
addReferencedMappings(refmap);
fixBaseClasses();
// generate the binding(s)
generateMappings(classes);
generateReferencedMappings(refmap);
generateFormats();
}
/**
* Generate binding(s) for lists of classes. This creates a <mapping> definition for each class in the lists, and
* either embeds <structure> definitions or creates separate <mapping>s for other classes referenced by these
* classes. If all the classes use the same namespace only the binding for that namespace will be created;
* otherwise, a separate binding will be created for each namespace.
*
* @param qnames list of names for concrete mappings
* @param concrs list of classes to be given concrete mappings
* @param abstrs list of classes to be given abstract mappings
*/
public void generateSpecified(ArrayList qnames, List concrs, List abstrs) {
// start by expanding and counting references from supplied classes
ReferenceCountMap refmap = new ReferenceCountMap();
m_directSet.addAll(concrs);
m_directSet.addAll(abstrs);
findReferences(concrs, refmap);
findReferences(abstrs, refmap);
flagMultipleReferences(refmap);
// set classes to be handled with mapping definitions
for (int i = 0; i < concrs.size(); i++) {
BindingMappingDetail detail = addMappingDetails(Boolean.FALSE, (QName)qnames.get(i), (String)concrs.get(i));
if (detail.getElementQName() == null) {
detail.setElementQName(fixElementName((QName)qnames.get(i)));
}
}
for (int i = 0; i < abstrs.size(); i++) {
addMappingDetails(Boolean.TRUE, null, (String)abstrs.get(i));
}
addReferencedMappings(refmap);
fixBaseClasses();
// generate the binding(s)
generateMappings(concrs);
generateMappings(abstrs);
generateReferencedMappings(refmap);
generateFormats();
}
/**
* Get the mapping details for a class. This method should only be used after the
* {@link #generate(Boolean, List)} method has been called.
*
* @param type fully-qualified class name
* @return mapping details, or null if none
*/
public BindingMappingDetail getMappingDetail(String type) {
return (BindingMappingDetail)m_mappingDetailsMap.get(type);
}
/**
* Get the binding definition for a namespace, which must already have been created. This method should only be used
* after the {@link #generate(Boolean, List)} method has been called. It delegates to the
* {@link org.jibx.binding.model.BindingOrganizer} implementation.
*
* @param uri
* @return binding holder
*/
public BindingHolder getBinding(String uri) {
return m_directory.getRequiredBinding(uri);
}
/**
* Adds a collection of namespace URIs to be referenced at root binding level.
*
* @param uris
*/
public void addRootUris(Collection uris) {
m_directory.addRootUris(uris);
}
/**
* Get the binding definition for a namespace, creating a new one if not previously defined. This method should only
* be used after the {@link #generate(Boolean, List)} method has been called. It delegates to the
* {@link org.jibx.binding.model.BindingOrganizer} implementation.
*
* @param uri
* @param dflt namespace is default for elements in binding flag
* @return binding holder
*/
public BindingHolder addBinding(String uri, boolean dflt) {
BindingHolder hold = m_directory.getBinding(uri);
if (hold == null) {
hold = m_directory.addBinding(uri, uri, null, dflt);
}
return hold;
}
/**
* Complete the generated bindings. This prepares the generated bindings for writing to the file system, if desired.
*
* @param name file name for root or singleton binding definition
* @return holder for root binding definition
*/
public BindingHolder finish(String name) {
BindingHolder root = m_directory.configureFiles(name, m_targetPackage, Collections.EMPTY_LIST);
return root;
}
/**
* Write and validate the generated binding definition files.
*
* @param dir target directory (bindings not written if null)
* @param loc class locator for binding validation (ignored if no target directory supplied)
* @param root holder for root binding definition
* @return binding definitions, or null if validation error
* @throws IOException
* @throws JiBXException
*/
public List validateFiles(File dir, IClassLocator loc, BindingHolder root) throws IOException, JiBXException {
// write the full set of binding definitions to target directory
m_directory.writeBindings(dir);
// validate the root binding (which will pull in all referenced bindings)
File file = new File(dir, root.getFileName());
ValidationContext vctx = new ValidationContext(loc);
FileInputStream is = new FileInputStream(file);
BindingElement binding = BindingElement.validateBinding(root.getFileName(), file.toURI().toURL(), is, vctx);
if (binding == null || vctx.getErrorCount() > 0 || vctx.getFatalCount() > 0) {
return null;
} else {
// build and return list of validated binding definitions
List uris = m_directory.getKeys();
List bindings = new ArrayList();
bindings.add(binding);
URL base = dir.toURI().toURL();
for (Iterator iter = uris.iterator(); iter.hasNext();) {
String uri = (String)iter.next();
BindingHolder hold = getBinding(uri);
if (hold != root) {
URL url = new URL(base, hold.getFileName());
if (binding.addIncludePath(url.toExternalForm(), false)) {
throw new IllegalStateException("Binding not found when read from file");
} else {
bindings.add(binding.getExistingIncludeBinding(url));
}
}
}
return bindings;
}
}
/**
* Run the binding generation using command line parameters.
*
* @param args
* @throws JiBXException
* @throws IOException
*/
public static void main(String[] args) throws JiBXException, IOException {
BindGenCommandLine parms = new BindGenCommandLine();
if (args.length > 0 && parms.processArgs(args)) {
// generate bindings for all classes
BindGen gen = new BindGen(parms.getGlobal());
gen.generate(parms.getAbstract(), parms.getExtraArgs());
BindingHolder root = gen.finish(parms.getBindingName());
List bindings = gen.validateFiles(parms.getGeneratePath(), parms.getLocator(), root);
if (!parms.isBindingOnly()) {
// generate schemas for all bindings
SchemaGen sgen = new SchemaGen(parms.getLocator(), parms.getGlobal(), parms.getUriNames());
List schemas = sgen.generate(bindings);
SchemaGen.writeSchemas(parms.getGeneratePath(), schemas);
}
} else {
if (args.length > 0) {
System.err.println("Terminating due to command line errors");
} else {
parms.printUsage();
}
System.exit(1);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/binding/generator/analysis/ 0000755 0001750 0001750 00000000000 11300355260 025065 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/schema/ 0000755 0001750 0001750 00000000000 11526304016 021105 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/schema/IReference.java 0000644 0001750 0001750 00000003515 11053530652 023765 0 ustar twerner twerner /*
* Copyright (c) 2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema;
import org.jibx.runtime.QName;
/**
* Interface for schema components referencing other components.
*/
public interface IReference
{
/**
* Get reference qualified name. This method is only usable after validation.
*
* @return qualified name, null if none
*/
QName getRef();
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/ISchemaResolver.java 0000644 0001750 0001750 00000005345 11252237150 025012 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema;
import java.io.IOException;
import java.io.InputStream;
/**
* Interface for resolving schema references which may be relative to a base location.
*/
public interface ISchemaResolver
{
/**
* Resolve a schema reference, which may be relative to this schema location. If a schema location is provided in
* the call that location should be used to identify the schema; the target namespace should only be used when
* the schema location is implicit.
*
* @param loc target URL (null if none supplied)
* @param tns target namespace URI (null if none supplied)
* @return resolver for target
* @throws IOException on resolve error
*/
public ISchemaResolver resolve(String loc, String tns) throws IOException;
/**
* Get the schema name.
*
* @return name
*/
public String getName();
/**
* Get unique identifier for this schema.
*
* @return identifier
*/
public String getId();
/**
* Get the content associated with this schema document.
*
* @return input stream
* @throws IOException on access error
*/
public InputStream getContent() throws IOException;
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/ISkipElements.java 0000644 0001750 0001750 00000003602 10651201410 024455 0 ustar twerner twerner /*
* Copyright (c) 2006, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema;
/**
* Interface for checking elements to be skipped in walking the definition tree.
*
* @author Dennis M. Sosnoski
*/
public interface ISkipElements
{
/**
* Check if a component is being skipped due to a fatal error.
*
* @param obj component to be checked
* @return flag for component being skipped
*/
boolean isSkipped(Object obj);
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/types/ 0000755 0001750 0001750 00000000000 11526304016 022251 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/schema/types/ShortBitSet.java 0000644 0001750 0001750 00000005530 10602646266 025343 0 ustar twerner twerner /*
Copyright (c) 2006, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.types;
/**
* Bit set stored as a short value.
*
* @author Dennis M. Sosnoski
*/
public class ShortBitSet
{
/** Array of bit masks. */
private static final char[] s_bitMasks = {
0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000, 0x8000
};
/** Mask for values in set. */
private char m_bits;
//
// Access methods
/**
* Check for value in set.
*
* @param value
* @return true if in set, false if not
*/
public boolean isSet(int value) {
return (m_bits & s_bitMasks[value]) != 0;
}
/**
* Include value in set.
*
* @param value
*/
public void add(int value) {
m_bits |= s_bitMasks[value];
}
/**
* Exclude value from set.
*
* @param value
*/
public void remove(int value) {
m_bits &= ~s_bitMasks[value];
}
/**
* Clear all values.
*/
public void clear() {
m_bits = 0;
}
/**
* Set all values in range.
*
* @param min minimum value in range
* @param max maximum value in range
*/
public void setRange(int min, int max) {
int mask = (s_bitMasks[max] << 1) - s_bitMasks[min];
m_bits |= mask;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/types/AllEnumSet.java 0000644 0001750 0001750 00000017272 11072763406 025146 0 ustar twerner twerner /*
Copyright (c) 2006, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.types;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.schema.validation.ValidationContext;
/**
* Bit set based on a string enumeration list with the added option of '#all'.
*
* @author Dennis M. Sosnoski
*/
public class AllEnumSet
{
/** Base enumeration. */
private final EnumSet m_enum;
/** Attribute name. */
private final String m_name;
/** Bit set for values from enumeration. */
private final ShortBitSet m_bits;
/** Flag for present (if false, other values ignored). */
private boolean m_present;
/** Flag for '#all' value. */
private boolean m_all;
/**
* Constructor.
*
* @param eset enumeration value set
* @param name attribute name
*/
public AllEnumSet(EnumSet eset, String name) {
m_enum = eset;
m_name = name;
m_bits = new ShortBitSet();
if (eset.maxIndex() > 15) {
throw new IllegalArgumentException("Too many values in enumeration");
}
}
//
// Needed for JiBX, but should never be called.
private AllEnumSet() {
throw new IllegalStateException("no-arg constructor should never be called");
}
//
// Access methods
/**
* Check if present.
*
* @return present
*/
public boolean isPresent() {
return m_present;
}
/**
* Set present.
*
* @param present
*/
public void setPresent(boolean present) {
m_present = present;
}
/**
* Check '#all' value.
*
* @return all
*/
public boolean isAll() {
return m_all;
}
/**
* Set '#all' value.
*
* @param all
*/
public void setAll(boolean all) {
m_all = all;
}
/**
* Add value to set.
*
* @param value
* @see org.jibx.schema.types.ShortBitSet#add(int)
*/
public void add(int value) {
m_present = true;
if (!m_all) {
m_bits.add(value);
}
}
/**
* Check if value in set.
*
* @param value
* @return true if value in set
* @see org.jibx.schema.types.ShortBitSet#isSet(int)
*/
public boolean isSet(int value) {
return m_present && (m_all || m_bits.isSet(value));
}
/**
* Remove value from set.
*
* @param value
* @see org.jibx.schema.types.ShortBitSet#remove(int)
*/
public void remove(int value) {
if (m_present) {
if (m_all) {
m_all = false;
m_bits.setRange(0, m_enum.maxIndex());
}
m_bits.remove(value);
}
}
/**
* Serializer method for output as value list.
*
* @return string value, or null if not present
*/
public String toString() {
if (m_present) {
if (m_all) {
return "#all";
} else {
StringBuffer buff = new StringBuffer();
for (int i = 0; i <= m_enum.maxIndex(); i++) {
if (m_bits.isSet(i)) {
if (buff.length() > 0) {
buff.append(' ');
}
buff.append(m_enum.getName(i));
}
}
return buff.toString();
}
} else {
return null;
}
}
/**
* Deserializer method for input as value list.
*
* @param text string value, or null if not present
* @param vctx
* @param obj object being validated
*/
public void fromString(String text, ValidationContext vctx, Object obj) {
if (text == null) {
m_present = false;
} else {
// indicate present
m_present = true;
m_all = false;
m_bits.clear();
// scan text to find whitespace breaks between items
int length = text.length();
int base = 0;
boolean space = true;
for (int i = 0; i < length; i++) {
char chr = text.charAt(i);
switch (chr) {
case 0x09:
case 0x0A:
case 0x0D:
case ' ':
// ignore if preceded by space
if (!space) {
// process name from list
addName(text.substring(base, i), vctx, obj);
space = true;
}
base = i + 1;
break;
default:
space = false;
break;
}
}
// finish last item
if (base < length) {
addName(text.substring(base), vctx, obj);
}
}
}
/**
* Deserializer method for unmarshalling input as value list.
*
* @param text string value, or null if not present
* @param ictx
*/
private void fromString(String text, IUnmarshallingContext ictx) {
fromString(text, (ValidationContext)ictx.getUserContext(),
ictx.getStackTop());
}
/**
* Process name from text list. This validates the name and adds it to the
* bit set.
*
* @param name
* @param vctx
* @param obj
*/
private void addName(String name, ValidationContext vctx, Object obj) {
if (m_all) {
vctx.addError("'#all' cannot be used with other values in '" +
m_name + "' attribute", obj);
} else if ("#all".equals(name)) {
m_all = true;
} else {
int index = m_enum.getValue(name);
if (index >= 0) {
m_bits.add(index);
} else {
vctx.addError("'" + name + "' is not valid for '" +
m_name + "' attribute value", obj);
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/types/Count.java 0000644 0001750 0001750 00000012533 10673570326 024223 0 ustar twerner twerner /*
Copyright (c) 2006, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.types;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.Utility;
/**
* Repetition count in a schema definition.
*
* @author Dennis M. Sosnoski
*/
public class Count
{
/** Predefined count of '0'. */
public static final Count COUNT_ZERO = new Count(0, false);
/** Predefined count of '1'. */
public static final Count COUNT_ONE = new Count(1, false);
/** Predefined count of 'unbounded'. */
public static final Count COUNT_UNBOUNDED = new Count(0, true);
/** Actual count for bounded value. */
private final int m_count;
/** Flag for unbounded value. */
private final boolean m_unbounded;
/**
* Internal constructor.
*
* @param count
* @param unbounded
*/
private Count(int count, boolean unbounded) {
m_count = count;
m_unbounded = unbounded;
}
/**
* Get count value. This method throws an exception if used with an
* unbounded value, so always try {@link #isUnbounded()} first.
*
* @return count
*/
public int getCount() {
if (m_unbounded) {
throw new IllegalStateException("Cannot get count for unbounded value");
} else {
return m_count;
}
}
/**
* Check for unbounded count.
*
* @return unbounded flag
*/
public boolean isUnbounded() {
return m_unbounded;
}
/**
* Check for count equal to a particular value. This is a convenience method
* which avoids the need to separately check unbounded and then compare the
* count.
*
* @param value
* @return equal flag
*/
public boolean isEqual(int value) {
return !m_unbounded && m_count == value;
}
/**
* Check for count greater than a particular value. This is a convenience
* method which avoids the need to separately check unbounded and then
* compare the count.
*
* @param value
* @return greater than flag
*/
public boolean isGreaterThan(int value) {
return m_unbounded || m_count > value;
}
/**
* Deserializer method for bounded values.
*
* @param value text representation
* @return instance of class
* @throws JiBXException on conversion error
*/
public static Count getBoundedCount(String value) throws JiBXException {
if (value == null) {
return null;
} else {
value = value.trim();
if ("0".equals(value)) {
return COUNT_ZERO;
} else if ("1".equals(value)) {
return COUNT_ONE;
} else {
return new Count(Utility.parseInt(value), false);
}
}
}
/**
* Deserializer method.
*
* @param value text representation
* @return instance of class (null if none)
* @throws JiBXException on conversion error
*/
public static Count getCount(String value) throws JiBXException {
if ("unbounded".equals(value)) {
return COUNT_UNBOUNDED;
} else {
return getBoundedCount(value);
}
}
/**
* Check if a count attribute is equal to a specified value. If the count is null, the value is
* taken as '1'.
*
* @param value
* @param count
* @return true if value equal, false if not
*/
public static boolean isCountEqual(int value, Count count) {
if (count == null) {
return value == 1;
} else {
return count.isEqual(value);
}
}
/**
* Conversion to text form.
*
* @return count as text
*/
public String toString() {
if (m_unbounded) {
return "unbounded";
} else {
return Utility.serializeInt(m_count);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/SchemaUtils.java 0000644 0001750 0001750 00000026636 11260361042 024203 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema;
import java.io.File;
import java.util.Iterator;
import org.apache.log4j.Logger;
import org.jibx.runtime.ITrackSource;
import org.jibx.schema.elements.AnnotatedBase;
import org.jibx.schema.elements.AttributeElement;
import org.jibx.schema.elements.ElementElement;
import org.jibx.schema.elements.FacetElement;
import org.jibx.schema.elements.FilteredSegmentList;
import org.jibx.schema.elements.OpenAttrBase;
import org.jibx.schema.elements.SchemaBase;
import org.jibx.schema.elements.SimpleRestrictionElement;
import org.jibx.schema.elements.SimpleTypeElement;
import org.jibx.schema.types.Count;
/**
* Utility methods for working with schema structures.
*
* @author Dennis M. Sosnoski
*/
public class SchemaUtils
{
/** Binding name for output with schema namespace prefix 'xs'. */
public static final String XS_PREFIX_BINDING = "schema_xsprefix_binding";
/** Binding name for output with schema namespace as default (no prefix). */
public static final String NO_PREFIX_BINDING = "schema_noprefix_binding";
/** Logger for class. */
public static final Logger s_logger = Logger.getLogger(SchemaUtils.class.getName());
/** String used as basis for indentation. */
private static final String s_indentText = " . . . . . . . . . . . . . . . . . . . . ";
/** Pregenerated indentation strings. */
private static final String[] s_indents;
static {
s_indents = new String[s_indentText.length()];
for (int i = 0; i < s_indents.length; i++) {
s_indents[i] = s_indentText.substring(0, i);
}
};
/**
* Check if a particle is a repeated value.
*
* @param part particle to be checked
* @return true if repeated, false if not
*/
public static boolean isRepeated(IArity part) {
Count max = part.getMaxOccurs();
return (max != null && (max.isGreaterThan(1)));
}
/**
* Check if a particle is prohibited (no instances allowed).
*
* @param part particle to be checked
* @return true if prohibited, false if not
*/
public static boolean isProhibited(IArity part) {
return Count.isCountEqual(0, part.getMaxOccurs());
}
/**
* Check if a particle is optional (zero instances allowed).
*
* @param part particle to be checked
* @return true if optional, false if not
*/
public static boolean isOptional(IArity part) {
return Count.isCountEqual(0, part.getMinOccurs());
}
/**
* Check if an element is optional (zero instances allowed).
*
* @param elem element to be checked
* @return true if optional, false if not
*/
public static boolean isOptionalElement(ElementElement elem) {
return Count.isCountEqual(0, elem.getMinOccurs()) || (elem.isNillable() && !isRepeated(elem));
}
/**
* Check if an attribute is optional (zero instances allowed).
*
* @param attr attribute to be checked
* @return true if optional, false if not
*/
public static boolean isOptionalAttribute(AttributeElement attr) {
return attr.getUse() == AttributeElement.OPTIONAL_USE;
}
/**
* Check if a particle is a singleton (one, and only one, instance allowed).
*
* @param part particle to be checked
* @return true if singleton, false if not
*/
public static boolean isSingleton(IArity part) {
return Count.isCountEqual(1, part.getMinOccurs()) && Count.isCountEqual(1, part.getMaxOccurs());
}
/**
* Check if an element is a singleton (one, and only one, instance allowed).
*
* @param elem element to be checked
* @return true if singleton, false if not
*/
public static boolean isSingletonElement(ElementElement elem) {
return !elem.isNillable() && isSingleton((IArity)elem);
}
/**
* Check if a definition component is nillable (an element with nillable='true').
*
* @param comp
* @return true if nillable, false if not
*/
public static boolean isNillable(OpenAttrBase comp) {
if (comp instanceof ElementElement) {
return ((ElementElement)comp).isNillable();
} else {
return false;
}
}
/**
* Check if a definition component has a name.
*
* @param comp
* @return true if named, false if not
*/
public static boolean isNamed(OpenAttrBase comp) {
if (comp instanceof INamed) {
return ((INamed)comp).getName() != null;
} else {
return false;
}
}
//
// Logging support
/**
* Get indentation string. This returns a string of the requested number of indents to the maximum value supported,
* and otherwise just returns the maximum indentation.
*
* @param depth
* @return indentation string
*/
public static String getIndentation(int depth) {
if (depth < s_indents.length) {
return s_indents[depth];
} else {
return s_indentText;
}
}
/**
* Get string description of component for use in logging.
*
* @param comp schema component
* @return description
*/
public static String describeComponent(SchemaBase comp) {
StringBuffer buff = new StringBuffer();
buff.append(comp.name());
String name;
if (comp instanceof INamed && (name = ((INamed)comp).getName()) != null) {
buff.append(' ');
buff.append(name);
}
if (comp instanceof ITrackSource) {
ITrackSource track = (ITrackSource)comp;
String path = track.jibx_getDocumentName();
if (path != null) {
buff.append(" (");
int start = path.lastIndexOf(File.separatorChar) + 1;
int end = path.length();
if (path.endsWith(".xsd")) {
end -= 4;
}
buff.append(path.substring(start, end));
int line = track.jibx_getLineNumber();
if (line > 0) {
buff.append(':');
buff.append(line);
}
buff.append(")");
}
}
return buff.toString();
}
/**
* Get path to component.
*
* @param comp schema component
* @return description
*/
public static String componentPath(OpenAttrBase comp) {
StringBuffer buff = new StringBuffer();
StringBuffer segment = new StringBuffer();
OpenAttrBase node = comp;
while (node != null && node.type() != SchemaBase.SCHEMA_TYPE) {
segment.append(node.name());
String name;
OpenAttrBase parent = node.getParent();
if (node instanceof INamed && (name = ((INamed)node).getName()) != null) {
segment.append("[@name=");
segment.append(name);
segment.append(']');
} else {
int index = 1;
if (parent != null) {
for (Iterator iter = parent.getChildIterator(); iter.hasNext();) {
OpenAttrBase child = (OpenAttrBase)iter.next();
if (child == node) {
break;
} else if (child.type() == node.type()) {
index++;
}
}
}
if (index > 1) {
segment.append('[');
segment.append(index);
segment.append(']');
}
}
if (buff.length() > 0) {
segment.append('/');
}
buff.insert(0, segment.toString());
segment.setLength(0);
node = parent;
}
if (comp instanceof ITrackSource) {
ITrackSource track = (ITrackSource)comp;
String path = track.jibx_getDocumentName();
if (path != null) {
buff.append(" (");
int start = path.lastIndexOf(File.separatorChar) + 1;
int end = path.length();
if (path.endsWith(".xsd")) {
end -= 4;
}
buff.append(path.substring(start, end));
int line = track.jibx_getLineNumber();
if (line > 0) {
buff.append(':');
buff.append(line);
}
buff.append(")");
}
}
return buff.toString();
}
/**
* Check if a particular schema definition component is an enumeration type definition. Formally, this returns
* true if and only if the component is a <simpleType> element which is a restriction using one or
* more <enumeration> facets.
*
* @param comp
* @return true if an enumeration definition, false if not
*/
public static boolean isEnumeration(AnnotatedBase comp) {
if (comp.type() == SchemaBase.SIMPLETYPE_TYPE) {
SimpleTypeElement type = (SimpleTypeElement)comp;
if (type.getDerivation().type() == SchemaBase.RESTRICTION_TYPE) {
SimpleRestrictionElement restrict = (SimpleRestrictionElement)type.getDerivation();
FilteredSegmentList facets = restrict.getFacetsList();
for (int i = 0; i < facets.size(); i++) {
FacetElement facet = (FacetElement)facets.get(i);
if (facet.type() == SchemaBase.ENUMERATION_TYPE) {
return true;
}
}
}
}
return false;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/ 0000755 0001750 0001750 00000000000 11526304016 022511 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/Item.java 0000644 0001750 0001750 00000035153 11300631736 024263 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.codegen.custom.ComponentExtension;
import org.jibx.schema.elements.AnnotatedBase;
import org.jibx.schema.elements.CommonTypeDerivation;
import org.jibx.schema.elements.ElementElement;
import org.jibx.schema.elements.SchemaBase;
/**
* Base class for code generation items. Each instance corresponds to a particular schema component, and this base class
* tracks that schema component (by way of the extension information), along with related details and linkage
* information. The linkage uses embedded list links, which allows replacing one instance with another with minimal
* overhead.
*
* @author Dennis M. Sosnoski
*/
public abstract class Item
{
/** Corresponding schema component extension. */
private final ComponentExtension m_componentExtension;
/** Flag for topmost item associated with a particular schema component. */
private final boolean m_topmost;
/** Flag for an optional item. In cases where multiple items are associated with the same schema component, this
is only meaningful for the topmost item. */
private final boolean m_optional;
/** Flag for a collection item. In cases where multiple items are associated with the same schema component, this
is only meaningful for the topmost item. */
private final boolean m_collection;
/** Flag for a nillable item. In cases where multiple items are associated with the same schema component, this
is only meaningful for the topmost item. */
private final boolean m_nillable;
/** Item is handled by subclassing flag. */
private boolean m_implicit;
/** Containing group item. */
private GroupItem m_parent;
/** Next item in list (null if none). */
protected Item m_next;
/** Preceding item in list (null if none). */
protected Item m_last;
/** Actual name to be used for item (null if to be inherited). */
private String m_name;
/**
* Basic constructor. This uses the schema component to determine all information other than the parent item group,
* including the optional/nillable/collection flags. As a special case, if the parent group is associated with the
* same component this sets all three of these flags false to avoid redundant handling.
*
* @param comp schema component
* @param parent containing group (null if a top-level group)
*/
protected Item(AnnotatedBase comp, GroupItem parent) {
// save basic values
m_componentExtension = (ComponentExtension)comp.getExtension();
m_parent = parent;
// set other values based on extension and component information
if (parent == null || parent.getSchemaComponent() != comp) {
m_topmost = true;
m_optional = m_componentExtension.isOptional();
m_collection = m_componentExtension.isRepeated();
m_nillable = comp.type() == SchemaBase.ELEMENT_TYPE && ((ElementElement)comp).isNillable();
} else {
m_topmost = m_optional = m_collection = m_nillable = false;
}
m_name = m_componentExtension.getBaseName();
}
/**
* Copy constructor. This creates a copy with a new parent.
*
* @param original
* @param ref reference (for name override; null if none)
* @param ext component extension to be linked with copy
* @param parent (non-null)
*/
protected Item(Item original, Item ref, ComponentExtension ext, GroupItem parent) {
m_componentExtension = ext;
m_parent = parent;
if (parent == null || parent.getSchemaComponent() != m_componentExtension.getComponent()) {
m_topmost = true;
Item top = original.getTopmost();
m_optional = top.m_optional;
m_collection = top.m_collection;
m_nillable = top.m_nillable;
} else {
m_topmost = m_optional = m_collection = m_nillable = false;
}
if (ref == null || original.isFixedName()) {
m_name = original.m_name;
} else {
m_name = ref.m_name;
}
}
/**
* Replace the parent for this item.
*
* @param parent
*/
protected void reparent(GroupItem parent) {
m_parent = parent;
}
/**
* Get schema component corresponding to this item.
*
* @return schema component
*/
public AnnotatedBase getSchemaComponent() {
return (AnnotatedBase)m_componentExtension.getComponent();
}
/**
* Get schema component annotation corresponding to this item.
*
* @return schema component
*/
public ComponentExtension getComponentExtension() {
return m_componentExtension;
}
/**
* Get containing group item.
*
* @return group (null if a top-level group)
*/
public GroupItem getParent() {
return m_parent;
}
/**
* Check if the name is fixed by configuration.
*
* @return true if fixed, false if not
*/
public boolean isFixedName() {
return m_componentExtension.getBaseName() != null;
}
/**
* Get effective item name, applying inheritance if necessary.
*
* @return name
*/
public String getEffectiveName() {
Item item = this;
while (item.m_name == null) {
item = item.m_parent;
if (item == null) {
throw new IllegalStateException("Inherited name with nothing to inherit");
}
}
return item.m_name;
}
/**
* Get name set directly for this item.
*
* @return name (null if to be inherited)
*/
public String getName() {
return m_name;
}
/**
* Set name directly for this item. It is an error to call this method if the name is fixed.
*
* @param name (null if to be inherited)
*/
public void setName(String name) {
if (isFixedName()) {
throw new IllegalStateException("Internal error - attempt to change configured name");
} else {
m_name = name;
}
}
/**
* Get next item in list.
*
* @return next
*/
public Item getNext() {
return m_next;
}
/**
* Check if topmost item for a particular schema component. The methods {@link #isCollection()},
* {@link #isOptional()}, {@link GroupItem#isAllOptional()}, {@link GroupItem#isAttributePresent()},
* {@link GroupItem#isContentPresent()}, and {@link GroupItem#isElementPresent()} are all only meaningful for the
* topmost item associated with a schema component.
*
* @return topmost
*/
public boolean isTopmost() {
return m_topmost;
}
/**
* Get the topmost item associated with the same schema component as this item. The methods {@link
* #isCollection()}, {@link #isOptional()}, {@link GroupItem#isAllOptional()}, {@link
* GroupItem#isAttributePresent()}, {@link GroupItem#isContentPresent()}, and {@link GroupItem#isElementPresent()}
* are all only meaningful for the topmost item associated with a schema component.
*
* @return topmost
*/
public Item getTopmost() {
Item top = this;
while (!top.isTopmost()) {
top = top.m_parent;
}
return top;
}
/**
* Check if item is optional. This method is only meaningful for the topmost item associated with a particular
* schema component (those for which {@link #isTopmost()} returns true).
*
* @return optional
*/
public boolean isOptional() {
return m_optional;
}
/**
* Check if item is ignored. This method is only meaningful for the topmost item associated with a particular
* schema component (those for which {@link #isTopmost()} returns true).
*
* @return optional
*/
public boolean isIgnored() {
return getComponentExtension().isIgnored();
}
/**
* Check if a collection item. This method is only meaningful for the topmost item associated with a particular
* schema component (those for which {@link #isTopmost()} returns true).
*
* @return true if collection
*/
public boolean isCollection() {
return m_collection;
}
/**
* Check if the item is represented implicitly by subclassing.
*
* @return implicit
*/
public boolean isImplicit() {
return m_implicit;
}
/**
* Set item represented implicitly by subclassing flag.
*
* @param implicit
*/
public void setImplicit(boolean implicit) {
m_implicit = implicit;
}
/**
* Copy the item under a different parent. This is intended for replacing a reference with a copy, and allows the
* reference to override settings from the original.
*
* @param ref reference (for overrides to copy; null if none)
* @param parent
* @return copy
*/
protected abstract Item copy(Item ref, GroupItem parent);
/**
* Find the nearest ancestor group which relates to a different schema component.
*
* @return ancestor with different schema component, or null if none
*/
protected GroupItem findDisjointParent() {
AnnotatedBase comp = getSchemaComponent();
GroupItem parent = getParent();
while (parent != null && parent.getSchemaComponent() == comp) {
parent = parent.getParent();
}
return parent;
}
/**
* Classify the content of this item as attribute, element, and/or character data content, and as requiring content
* of some form if appropriate. This needs to be done as a separate step after construction in order to handle
* references, which must assume the content of the definition, and also to work after inlining. This base class
* implementation does the classification based solely on the schema component type. Any subclasses which override
* this method should generally call the base class implementation before doing their own classification handling,
* unless they use a substitute component.
*/
protected void classifyContent() {
if (m_topmost) {
// find the parent group with a different schema component
GroupItem parent = findDisjointParent();
if (parent != null) {
// flag content type for that parent group
AnnotatedBase comp = getSchemaComponent();
switch (comp.type()) {
case SchemaBase.ANY_TYPE:
case SchemaBase.ELEMENT_TYPE:
// set required component present if appropriate
if (!m_optional) {
parent.forceRequiredPresent();
}
// fall through for common handling
case SchemaBase.GROUP_TYPE:
parent.forceElementPresent();
break;
case SchemaBase.EXTENSION_TYPE:
CommonTypeDerivation deriv = (CommonTypeDerivation)comp;
if (!deriv.isComplexType()) {
parent.forceContentPresent();
parent.forceRequiredPresent();
}
break;
case SchemaBase.ANYATTRIBUTE_TYPE:
case SchemaBase.ATTRIBUTE_TYPE:
// set required component present if appropriate
if (!m_optional) {
parent.forceRequiredPresent();
}
// fall through for common handling
case SchemaBase.ATTRIBUTEGROUP_TYPE:
parent.forceAttributePresent();
break;
}
}
}
}
/**
* Generate a description of the item. For items with nested items this will show the complete structure.
*
* @param depth current nesting depth
* @param classified include classification details flag
* @return description
*/
protected abstract String describe(int depth, boolean classified);
/**
* Generate the standard leading text for description of the item.
*
* @param depth current nesting depth
* @return leading text for description
*/
protected String leadString(int depth) {
StringBuffer buff = new StringBuffer(SchemaUtils.getIndentation(depth));
if (isOptional()) {
buff.append("optional ");
}
if (isCollection()) {
buff.append("repeating ");
}
return buff.toString();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/PackageOrganizer.java 0000644 0001750 0001750 00000034612 11260361042 026573 0 ustar twerner twerner /*
* Copyright (c) 2006-2009, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import org.jibx.runtime.Utility;
import org.jibx.util.InsertionOrderedMap;
/**
* Organizer for package information. This handles the conversions from namespace URIs to package names, and organizes
* the packages in a tree structure.
*
* @author Dennis M. Sosnoski
*/
public class PackageOrganizer
{
//
// Instance data
/** Base directory for code generation. */
private final File m_generateDirectory;
/** Leading URI text to be matched (paired with replacement values). These values are matched using case-insensitive
comparisons. */
private String[] m_namespaceLeadMatches;
/** Replacement text for URI matches (paired with leading URI texts). */
private String[] m_namespaceLeadReplaces;
/** Map from schema namespace URI to package (empty if unused). */
private Map m_namespacePackageMap;
/** Map from package to base directory for code generation (empty if unused). */
private Map m_packageDirectoryMap;
/** Array of case-insensitive strings to be discarded from start of authority component of URI when converting to
package name. The default is the string "www." */
private String[] m_authorityDiscards = new String[] { "www." };
/** Map from namespace URI to package information. This is used in combination with the name-package map, since
multiple URIs may be converted to the same package name. */
private Map m_uriPackageMap;
/** Map from package name to package information. This is used in combination with the URI-package map. */
private InsertionOrderedMap m_namePackageMap;
/** Package to use for no-namespace schema components. */
private String m_noNamespacePackage;
/**
* Constructor.
*
* @param basedir default base directory for code generation
* @param npkg default package for no-namespace schema components
*/
public PackageOrganizer(File basedir, String npkg) {
m_generateDirectory = basedir;
m_namespaceLeadMatches = Utility.EMPTY_STRING_ARRAY;
m_namespaceLeadReplaces = Utility.EMPTY_STRING_ARRAY;
m_namespacePackageMap = Collections.EMPTY_MAP;
m_packageDirectoryMap = Collections.EMPTY_MAP;
m_uriPackageMap = new HashMap();
m_namePackageMap = new InsertionOrderedMap();
m_noNamespacePackage = npkg;
m_namePackageMap.put("", new PackageHolder("", basedir, null));
}
/**
* Set the namespace lead replacement patterns. This consists of lead texts to be matches and paired replacement
* texts. When a particular lead text is found in a URI the replacement text is substituted.
*
* @param leads
* @param repls
*/
public void setNamespaceLeadReplaces(String[] leads, String[] repls) {
m_namespaceLeadMatches = leads;
}
/**
* Set map from namespace URIs to packages.
*
* @param map String-to-String map
*/
public void setNSPackageMap(Map map) {
m_namespacePackageMap = map;
}
/**
* Set map from package to base generation directory. If this is unset all packages are generated under the default
* base directory, as are any packages not covered by this map. All subpackages of a package go under the parent
* package unless otherwise specified by this map.
*
* @param map String-to-File map
*/
public void setPackageDirMap(Map map) {
m_packageDirectoryMap = map;
}
/**
* Check if a character is a hex digit.
*
* @param chr
* @return hex digit flag
*/
private boolean isHexChar(char chr) {
return (chr >= '0' && chr <= '9') || (chr >= 'a' && chr <= 'z') || (chr >= 'A' && chr <= 'Z');
}
/**
* Get value of character as hex digit.
*
* @param chr
* @return hex digit value
*/
private int hexValue(char chr) {
if (chr >= '0' && chr <= '9') {
return chr - '0';
} else {
return Character.toLowerCase(chr) - 'a' + 10;
}
}
/**
* Check if a character is an ASCII alpha character.
*
* @param chr
* @return alpha character flag
*/
private static boolean isAsciiAlpha(char chr) {
return (chr >= 'a' && chr <= 'z') || (chr >= 'A' && chr <= 'Z');
}
/**
* Check if a character is an ASCII numeric character.
*
* @param chr
* @return numeric character flag
*/
private static boolean isAsciiNum(char chr) {
return chr >= '0' && chr <= '9';
}
/**
* Check if a character is an ASCII alpha or numeric character.
*
* @param chr
* @return alpha or numeric character flag
*/
private static boolean isAsciiAlphaNum(char chr) {
return isAsciiAlpha(chr) || isAsciiNum(chr);
}
/**
* Convert namespace URI to package name.
*
* @param uri
* @return package name
*/
public String uriToPackage(String uri) {
// first check for no-namespace namespace
if (uri.length() == 0) {
return m_noNamespacePackage;
}
// substitute URI lead text matches
String pname = uri.toLowerCase();
for (int i = 0; i < m_namespaceLeadMatches.length; i++) {
String lead = m_namespaceLeadMatches[i];
if (pname.startsWith(lead)) {
pname = m_namespaceLeadReplaces[i] + pname.substring(lead.length());
break;
}
}
// force expected path separator characters
pname = pname.replace('\\', '/');
// discard leading scheme in namespace URI
int split = pname.indexOf(':');
if (split > 0 && isAsciiAlpha(pname.charAt(0))) {
boolean scheme = true;
for (int i = 0; i < split; i++) {
char chr = pname.charAt(i);
if (!isAsciiAlphaNum(chr) && chr != '-' && chr != '+' && chr != '.') {
scheme = false;
break;
}
}
if (scheme) {
pname = pname.substring(split + 1);
}
}
// delete any port number component
int base = pname.indexOf(':');
if (base > 0) {
int tail;
for (tail = base + 1; tail < pname.length(); tail++) {
if (!isAsciiNum(pname.charAt(tail))) {
break;
}
}
pname = pname.substring(0, base) + pname.substring(tail);
}
// preprocess authority, if present, discarding leading matches
if (pname.startsWith("//")) {
pname = pname.substring(2);
for (int i = 0; i < m_authorityDiscards.length; i++) {
String match = m_authorityDiscards[i];
if (pname.startsWith(match)) {
pname = pname.substring(match.length());
}
}
}
// treat '@' the same as authority (e.g. 'mailto:dms@sosnoski.com')
pname = pname.replace('@', '.');
// find end of authority (or first directory in path, don't care)
int end = pname.indexOf('/');
if (end < 0) {
end = pname.length();
}
// reverse order of components in authority
StringBuffer buff = new StringBuffer(pname.length());
int mark = end;
while ((split = pname.lastIndexOf('.', --mark)) >= 0) {
if (buff.length() > 0) {
buff.append(pname.substring(split, mark + 1));
} else {
buff.append(pname.substring(split + 1, mark + 1));
}
mark = split;
}
if (mark >= 0) {
if (buff.length() > 0) {
buff.append('.');
}
buff.append(pname.substring(0, mark + 1));
}
pname = pname.substring(end);
// treat colons as path separators
pname = pname.replace(':', '/');
// delete file extension, if present
split = pname.lastIndexOf('.');
if (split > 0 && split > pname.lastIndexOf('/')) {
pname = pname.substring(0, split);
}
buff.append(pname);
// finish by converting path separators and special characters
int index = 0;
boolean first = true;
while (index < buff.length()) {
char chr = buff.charAt(index);
boolean delete = false;
if (chr == '.') {
if (first) {
delete = true;
} else {
first = true;
}
} else if (chr == '/') {
if (first) {
delete = true;
} else {
buff.setCharAt(index, '.');
first = true;
}
} else if (chr == '+') {
buff.setCharAt(index, '_');
first = false;
} else if (chr == '%') {
if (index + 2 < buff.length()) {
char chr1 = buff.charAt(index + 1);
char chr2 = buff.charAt(index + 2);
if (isHexChar(chr1) && isHexChar(chr2)) {
buff.setCharAt(index, (char)(hexValue(chr1) * 16 + hexValue(chr2)));
buff.delete(index + 1, index + 3);
continue;
}
} else {
delete = true;
}
} else if (isAsciiAlpha(chr) || (!first && isAsciiNum(chr))) {
first = false;
} else {
delete = true;
}
if (delete) {
buff.deleteCharAt(index);
} else {
index++;
}
}
if (first && buff.length() > 0) {
buff.setLength(buff.length() - 1);
}
return buff.toString();
}
/**
* Get package information based on package name.
*
* @param pname
* @return package information
*/
public PackageHolder getPackage(String pname) {
PackageHolder pkg = (PackageHolder)m_namePackageMap.get(pname);
if (pkg == null) {
// package doesn't exist yet, start by finding the parent package
int split = pname.lastIndexOf('.');
PackageHolder parent;
if (split >= 0) {
parent = getPackage(pname.substring(0, split));
} else if (pname.length() > 0) {
parent = getPackage("");
} else {
return new PackageHolder("", m_generateDirectory, null);
}
// check for specified generation directory
File gendir = (File)m_packageDirectoryMap.get(pname);
if (gendir == null) {
File pardir = parent.getGenerateDirectory();
if (pardir != null) {
// set directory path based on parent directory
gendir = new File(pardir, pname.substring(split + 1));
}
}
// create the package information
pkg = new PackageHolder(pname, gendir, parent);
m_namePackageMap.put(pname, pkg);
}
return pkg;
}
/**
* Get the information for a package.
*
* @param uri corresponding namespace URI (non-null, empty string for no namespace)
* @return package information
*/
public PackageHolder getPackageForUri(String uri) {
// first check for existing package
PackageHolder pkg = (PackageHolder)m_uriPackageMap.get(uri);
if (pkg == null) {
// first check direct mapping of namespace URI to package name
String pname = null;
if (m_namespacePackageMap != null) {
pname = (String)m_namespacePackageMap.get(uri);
}
// otherwise convert URI to package name
if (pname == null) {
pname = uriToPackage(uri);
}
// get package and add to map
pkg = getPackage(pname);
m_uriPackageMap.put(uri, pkg);
}
return pkg;
}
/**
* Get the defined packages. The returned list is guaranteed to be ordered such that parent packages precede child
* packages.
*
* @return packages
*/
public ArrayList getPackages() {
ArrayList keys = m_namePackageMap.keyList();
ArrayList packs = new ArrayList();
for (int i = 0; i < keys.size(); i++) {
packs.add(m_namePackageMap.get(keys.get(i)));
}
return packs;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/ExpressionBuilderBase.java 0000644 0001750 0001750 00000010170 11002543776 027623 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.CharacterLiteral;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.StringLiteral;
/**
* Abstract syntax tree expression builder base. This is used for expressions with multiple component operands. It adds
* convenience methods and control information to the base builder.
*/
public abstract class ExpressionBuilderBase extends ASTBuilderBase
{
/** Source builder. */
protected final ClassBuilder m_source;
/** Expression under construction. */
protected final Expression m_expression;
/**
* Constructor.
*
* @param source
* @param expr
*/
public ExpressionBuilderBase(ClassBuilder source, Expression expr) {
super(source.getAST());
m_source = source;
m_expression = expr;
}
/**
* Get expression. This is provided only for use by other classes in this package.
*
* @return expression
*/
Expression getExpression() {
return m_expression;
}
/**
* Add operand to expression. This must be implemented by each subclass to handle adding another operand.
*
* @param operand
*/
protected abstract void addOperand(Expression operand);
/**
* Add a local variable or field name operand to expression.
*
* @param name
*/
public void addVariableOperand(String name) {
addOperand(m_ast.newSimpleName(name));
}
/**
* Add a string literal operand to expression.
*
* @param value
*/
public void addStringLiteralOperand(String value) {
StringLiteral strlit = m_ast.newStringLiteral();
strlit.setLiteralValue(value);
addOperand(strlit);
}
/**
* Add a character literal operand to expression.
*
* @param value
*/
public void addCharacterLiteralOperand(char value) {
CharacterLiteral literal = m_ast.newCharacterLiteral();
literal.setCharValue(value);
addOperand(literal);
}
/**
* Add a number literal operand to expression.
*
* @param value
*/
public void addNumberLiteralOperand(String value) {
addOperand(m_ast.newNumberLiteral(value));
}
/**
* Add a null literal operand to expression.
*/
public void addNullOperand() {
addOperand(m_ast.newNullLiteral());
}
/**
* Add another expression as an operand.
*
* @param builder expression builder
*/
public void addOperand(ExpressionBuilderBase builder) {
addOperand(builder.m_expression);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/StringKeyed.java 0000644 0001750 0001750 00000004375 10752422370 025621 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
/**
* Base class for a data representation using a string value as a key. This just holds the key and implements the
* Comparable interface.
*/
public class StringKeyed implements Comparable
{
/** Key string. */
private final String m_key;
/**
* Constructor.
*
* @param key
*/
public StringKeyed(String key) {
m_key = key;
}
/**
* Get the key string.
*
* @return key
*/
public String getKey() {
return m_key;
}
/**
* Compare to another instance.
*
* @param o other instance
* @return difference
*/
public int compareTo(Object o) {
return m_key.compareTo(((StringKeyed)o).m_key);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/ItemVisitor.java 0000644 0001750 0001750 00000035376 11362660404 025654 0 ustar twerner twerner /*
* Copyright (c) 2006-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.apache.log4j.Logger;
import org.jibx.runtime.QName;
import org.jibx.schema.SchemaContextTracker;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.SchemaVisitor;
import org.jibx.schema.TreeWalker;
import org.jibx.schema.codegen.custom.GlobalExtension;
import org.jibx.schema.elements.AnnotatedBase;
import org.jibx.schema.elements.AnyElement;
import org.jibx.schema.elements.AttributeElement;
import org.jibx.schema.elements.AttributeGroupRefElement;
import org.jibx.schema.elements.CommonCompositorDefinition;
import org.jibx.schema.elements.CommonTypeDefinition;
import org.jibx.schema.elements.ComplexExtensionElement;
import org.jibx.schema.elements.ComplexRestrictionElement;
import org.jibx.schema.elements.ElementElement;
import org.jibx.schema.elements.GroupRefElement;
import org.jibx.schema.elements.ListElement;
import org.jibx.schema.elements.SimpleExtensionElement;
import org.jibx.schema.elements.SimpleRestrictionElement;
import org.jibx.schema.elements.SimpleTypeElement;
import org.jibx.schema.elements.UnionElement;
import org.jibx.schema.support.SchemaTypes;
/**
* Visitor to build the code generation items corresponding to a component.
*/
public class ItemVisitor extends SchemaVisitor
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(ItemVisitor.class.getName());
/** Extension information for the global definition being constructed. */
private GlobalExtension m_global;
/** Group currently being constructed. */
private GroupItem m_group;
/** Nesting depth, tracked for indenting of debug information. */
private int m_nestingDepth;
/**
* Build the item structure corresponding to a schema global definition component. This sets the structure on the
* global component extension before filling in the details, so that circular references won't cause a problem.
*
* @param comp
* @return constructed structure
*/
public DefinitionItem buildGlobal(AnnotatedBase comp) {
if (s_logger.isDebugEnabled()) {
s_logger.debug(SchemaUtils.getIndentation(m_nestingDepth) + "Building structure for global definition " +
SchemaUtils.describeComponent(comp));
m_nestingDepth++;
}
DefinitionItem definition = new DefinitionItem(comp);
m_group = definition;
m_global = (GlobalExtension)comp.getExtension();
m_global.setDefinition(definition);
TreeWalker wlkr = new TreeWalker(null, new SchemaContextTracker());
wlkr.walkElement(comp, this);
if (s_logger.isDebugEnabled()) {
m_nestingDepth--;
s_logger.debug(SchemaUtils.getIndentation(m_nestingDepth) + "Completed structure for global definition " +
SchemaUtils.describeComponent(comp) + " with " + m_group.getChildCount() + " child items");
}
return definition;
}
/**
* Build the item structure corresponding to a particular schema component. The supplied component can be a nested
* type definition or a nested compositor. This method may be called recursively, so it needs to save and restore
* the entry state.
*
* @param isenum enumeration flag
* @param comp schema component (should be the simpleType component in the case of an enumeration)
* @return constructed structure
*/
private GroupItem buildStructure(boolean isenum, AnnotatedBase comp) {
// first build the structure
if (s_logger.isDebugEnabled()) {
s_logger.debug(SchemaUtils.getIndentation(m_nestingDepth) + "building structure for component " +
SchemaUtils.describeComponent(comp));
m_nestingDepth++;
}
GroupItem hold = m_group;
m_group = hold.addGroup(comp);
m_group.setEnumeration(isenum);
// walk the nested definition to add details to structure
TreeWalker wlkr = new TreeWalker(null, new SchemaContextTracker());
wlkr.walkChildren(comp, this);
// return the structure
GroupItem ret = m_group;
if (s_logger.isDebugEnabled()) {
m_nestingDepth--;
s_logger.debug(SchemaUtils.getIndentation(m_nestingDepth) + "completed structure for component " +
SchemaUtils.describeComponent(comp) + " with " + m_group.getChildCount() + " child items");
}
m_group = hold;
return ret;
}
/**
* Add a reference to a global definition to the structure.
*
* @param comp referencing schema component
* @param ref referenced schema component
*/
private void addReference(AnnotatedBase comp, AnnotatedBase ref) {
DefinitionItem definition = ((GlobalExtension)ref.getExtension()).getDefinition();
if (definition == null) {
GroupItem holdstruct = m_group;
int holddepth = m_nestingDepth;
definition = buildGlobal(ref);
m_group = holdstruct;
m_nestingDepth = holddepth;
}
m_group.addReference(comp, definition);
}
/**
* Get the data type information for a built-in schema type.
*
* @param def schema type definition
* @return type information
*/
private JavaType getSchemaType(CommonTypeDefinition def) {
String name = def.getName();
JavaType type = (JavaType)m_global.getSchemaTypes().get(name);
if (type == null) {
throw new IllegalArgumentException("Unknown schema type '" + name + '\'');
} else {
return type;
}
}
/**
* Build an item from a type reference. For a predefined schema type this will be a simple {@link ValueItem}
* wrapped in a {@link GroupItem}; for a global type it will be a reference to a global definition.
*
* @param comp
* @param def
*/
private void addTypeRefItem(AnnotatedBase comp, CommonTypeDefinition def) {
if (def.isPredefinedType()) {
GroupItem group = m_group.addGroup(comp);
group.addValue(comp, def.getQName(), getSchemaType(def));
} else {
addReference(comp, def);
}
}
//
// Visit methods for generating values to classes
/**
* Visit <any> definition.
*
* @param node
* @return false to block further expansion
*/
public boolean visit(AnyElement node) {
if (!SchemaUtils.isProhibited(node)) {
m_group.addAny(node);
}
return false;
}
/**
* Visit <attribute> definition.
*
* @param node
* @return false to block further expansion
*/
public boolean visit(AttributeElement node) {
if (node.getUse() != AttributeElement.PROHIBITED_USE) {
// check for direct definition (rather than reference)
AttributeElement refattr = node.getReference();
if (refattr == null) {
if (node.getType() == null) {
// create a group for the embedded definition
buildStructure(false, node);
} else {
// handle reference to global or predefined type
addTypeRefItem(node, node.getTypeDefinition());
}
} else {
// use reference to definition structure
addReference(node, node.getReference());
}
}
return false;
}
/**
* Visit <attributeGroup> reference.
*
* @param node
* @return false to block further expansion
*/
public boolean visit(AttributeGroupRefElement node) {
addReference(node, node.getReference());
return false;
}
/**
* Visit compositor.
*
* @param node
* @return false to block further expansion
*/
public boolean visit(CommonCompositorDefinition node) {
buildStructure(false, node);
return false;
}
/**
* Visit complex type <extension> definition. This adds a reference item for the base type, then continues
* expansion to handle the items added by extension.
*
* @param node
* @return true to continue expansion
*/
public boolean visit(ComplexExtensionElement node) {
CommonTypeDefinition base = node.getBaseType();
if (base != SchemaTypes.ANY_TYPE) {
addReference(node, base);
}
return true;
}
/**
* Visit complex type <restriction> definition. This adds a reference item for the base type, blocking further
* expansion.
*
* @param node
* @return false to end expansion
*/
public boolean visit(ComplexRestrictionElement node) {
CommonTypeDefinition base = node.getBaseType();
if (base != SchemaTypes.ANY_TYPE) {
addReference(node, base);
}
return false;
}
/**
* Visit <element> definition.
*
* @param node
* @return false to block further expansion
*/
public boolean visit(ElementElement node) {
if (!SchemaUtils.isProhibited(node)) {
// check if direct definition
ElementElement refelem = node.getReference();
if (refelem == null) {
if (node.getType() == null || node.getType().equals(SchemaTypes.ANY_TYPE.getQName())) {
// create a group for the embedded definition
buildStructure(false, node);
} else {
// handle reference to global or predefined type
addTypeRefItem(node, node.getTypeDefinition());
}
} else {
// use reference to definition structure
addReference(node, refelem);
}
}
return false;
}
/**
* Visit <group> reference.
*
* @param node
* @return false to block further expansion
*/
public boolean visit(GroupRefElement node) {
addReference(node, node.getReference());
return false;
}
/**
* Visit <list> element. This adds a collection value matching the type of list.
*
* @param node
* @return false to block further expansion
*/
public boolean visit(ListElement node) {
QName type = node.getItemType();
if (type == null) {
buildStructure(false, node);
} else {
addTypeRefItem(node, node.getItemTypeDefinition());
}
return false;
}
/**
* Visit simple type <extension> element.
*
* @param node
* @return true to continue expansion
*/
public boolean visit(SimpleExtensionElement node) {
addTypeRefItem(node, node.getBaseType());
return true;
}
/**
* Visit simple type <restriction> element.
*
* @param node
* @return false to block further expansion
*/
public boolean visit(SimpleRestrictionElement node) {
CommonTypeDefinition type = node.getBaseType();
if (type == null) {
buildStructure(false, node.getDerivation());
} else {
addTypeRefItem(node, type);
}
return false;
}
/**
* Visit <simpleType> element. This checks for the special case of a type definition which consists of an
* enumeration, and adds a group to represent the enumeration if found.
*
* @param node
* @return true to continue expansion, unless processed as group
*/
public boolean visit(SimpleTypeElement node) {
if (SchemaUtils.isEnumeration(node)) {
// check if already an associated group (as will be for global type definition)
if (m_group.getSchemaComponent() == node) {
m_group.setEnumeration(true);
} else {
buildStructure(true, node);
return false;
}
}
return true;
}
/**
* Visit <union> element. This directly builds a structure matching the component types of the union, with the
* nested types handled directly and the referenced types added separately.
*
* @param node
* @return true to expand any inline types
*/
public boolean visit(UnionElement node) {
GroupItem struct = buildStructure(false, node);
CommonTypeDefinition[] types = node.getMemberTypeDefinitions();
if (types != null) {
for (int i = 0; i < types.length; i++) {
CommonTypeDefinition type = types[i];
if (type.isPredefinedType()) {
struct.addValue(node, type.getQName(), getSchemaType(type));
} else {
GroupItem hold = m_group;
m_group = struct;
addReference(node, type);
m_group = hold;
}
}
}
return false;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/SchemaCommandLineBase.java 0000644 0001750 0001750 00000016755 11317656254 027510 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.jibx.custom.CustomizationCommandLineBase;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IUnmarshallable;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.codegen.custom.SchemasetCustom;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.schema.validation.ValidationProblem;
import org.jibx.util.ReflectionUtilities;
/**
* Command line processing for tools working with schemas.
* TODO: take schema root directory handling from CodeGenCommandLine
*
* @author Dennis M. Sosnoski
*/
public abstract class SchemaCommandLineBase extends CustomizationCommandLineBase
{
/** Ordered array of extra usage lines. */
private static final String[] EXTRA_USAGE_LINES = new String[] {
" -s schema root directory path" };
/** Schema root URL path. */
private String m_rootPath;
/** Root URL for schemas. */
private URL m_schemaRoot;
/** Root directory for schemas (null if not a file system root). */
private File m_schemaDir;
/** Customizations model root. */
private SchemasetCustom m_customRoot;
/**
* Constructor.
*/
public SchemaCommandLineBase() {
super(EXTRA_USAGE_LINES);
}
/**
* Get root URL for schemas.
*
* @return directory
*/
public URL getSchemaRoot() {
return m_schemaRoot;
}
/**
* Get root directory for schemas.
*
* @return directory (null if root is not a directory)
*/
public File getSchemaDir() {
return m_schemaDir;
}
/**
* Get customizations model root.
*
* @return customizations
*/
public SchemasetCustom getCustomRoot() {
return m_customRoot;
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.CustomizationCommandLineBase#checkParameter(org.jibx.binding.generator.CustomizationCommandLineBase.ArgList)
*/
protected boolean checkParameter(ArgList alist) {
boolean match = true;
String arg = alist.current();
if ("-s".equalsIgnoreCase(arg)) {
m_rootPath = alist.next();
} else {
match = super.checkParameter(alist);
}
return match;
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.CustomizationCommandLineBase#verboseDetails
*/
protected void verboseDetails() {
System.out.println("Starting from schemas:");
List schemas = getExtraArgs();
for (int i = 0; i < schemas.size(); i++) {
System.out.println(" " + schemas.get(i));
}
}
/**
* Finish processing of command line parameters. This just sets up the schema directory.
*
* @param alist
*/
protected void finishParameters(ArgList alist) {
super.finishParameters(alist);
try {
if (m_rootPath == null) {
m_schemaRoot = new File(".").toURI().toURL();
m_schemaDir = new File(".");
} else {
String path = m_rootPath;
File pathfile = new File(path);
if (pathfile.exists()) {
m_schemaDir = pathfile;
m_schemaRoot = pathfile.toURI().toURL();
} else {
if (!path.endsWith("/")) {
path += '/';
}
m_schemaRoot = new URL(path);
if (m_schemaRoot.getProtocol().equals("file")) {
m_schemaDir = new File(m_schemaRoot.getPath());
}
}
}
} catch (MalformedURLException e) {
System.out.println("Root path '" + m_rootPath + "' not found as file and not recognized as URL");
alist.setValid(false);
}
}
/**
* Load the customizations file. This method must load the specified customizations file, or create a default
* customizations instance, of the appropriate type.
*
* @param path customization file path
* @return true if successful, false if an error
* @throws JiBXException
* @throws IOException
*/
protected boolean loadCustomizations(String path) throws JiBXException, IOException {
// load customizations and check for errors
ValidationContext vctx = new ValidationContext();
m_customRoot = new SchemasetCustom((SchemasetCustom)null);
if (path != null) {
IBindingFactory fact = BindingDirectory.getFactory(SchemasetCustom.class);
IUnmarshallingContext ictx = fact.createUnmarshallingContext();
FileInputStream is = new FileInputStream(path);
ictx.setDocument(is, null);
ictx.setUserContext(vctx);
((IUnmarshallable)m_customRoot).unmarshal(ictx);
}
ArrayList probs = vctx.getProblems();
if (probs.size() > 0) {
for (int i = 0; i < probs.size(); i++) {
ValidationProblem prob = (ValidationProblem)probs.get(i);
System.out.print(prob.getSeverity() >=
ValidationProblem.ERROR_LEVEL ? "Error: " : "Warning: ");
System.out.println(prob.getDescription());
}
if (vctx.getErrorCount() > 0 || vctx.getFatalCount() > 0) {
return false;
}
}
return true;
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.CustomizationCommandLineBase#applyOverrides(Map)
*/
protected Map applyOverrides(Map overmap) {
return ReflectionUtilities.applyKeyValueMap(overmap, m_customRoot);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/PackageHolder.java 0000644 0001750 0001750 00000021121 11221711652 026042 0 ustar twerner twerner /*
* Copyright (c) 2006-2009, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import org.eclipse.jdt.core.dom.AST;
import org.jibx.binding.model.BindingOrganizer;
import org.jibx.binding.model.BindingHolder;
import org.jibx.schema.codegen.extend.ClassDecorator;
import org.jibx.schema.codegen.extend.NameConverter;
import org.jibx.util.UniqueNameSet;
/**
* Information for a package to be included in code generated from schema.
*
* @author Dennis M. Sosnoski
*/
public class PackageHolder
{
/** Full package name (dot-separated form). */
private final String m_packageName;
/** Target directory for code generation. */
private final File m_generateDirectory;
/** Information for parent package. */
private final PackageHolder m_parentPackage;
/** Set of class names used in package. */
private final UniqueNameSet m_nameSet;
/** List of top-level classes in package. */
private final ArrayList m_classes;
/** List of all classes in package, including inner classes. */
private final ArrayList m_allClasses;
/** Number of subpackages of this package. */
private int m_subpackageCount;
/**
* Constructor.
*
* @param name full package name (dot-separated form)
* @param dir target directory for code generation (null if skipping code generation)
* @param parent parent package information
*/
public PackageHolder(String name, File dir, PackageHolder parent) {
m_packageName = name;
m_generateDirectory = dir;
m_parentPackage = parent;
if (m_parentPackage != null) {
m_parentPackage.m_subpackageCount++;
}
m_nameSet = new UniqueNameSet();
m_classes = new ArrayList();
m_allClasses = new ArrayList();
}
/**
* Get generate directory.
*
* @return generate directory
*/
public File getGenerateDirectory() {
return m_generateDirectory;
}
/**
* Get parent package.
*
* @return parent package
*/
public PackageHolder getParent() {
return m_parentPackage;
}
/**
* Get fully-qualified package name.
*
* @return name
*/
public String getName() {
return m_packageName;
}
/**
* Get the number of top-level classes in package.
*
* @return count
*/
public int getTopClassCount() {
return m_classes.size();
}
/**
* Get the total number of classes (including inner classes) in package.
*
* @return count
*/
public int getClassCount() {
return m_allClasses.size();
}
/**
* Get the number of subpackages created for this package.
*
* @return count
*/
public int getSubpackageCount() {
return m_subpackageCount;
}
/**
* Add class to package.
*
* @param name preferred name for class
* @param nconv name converter for class
* @param decorators class decorators
* @param inner use inner classes for substructures
* @param enumer enumeration class flag
* @param holder binding holder
* @return class generator
*/
public ClassHolder addClass(String name, NameConverter nconv, ClassDecorator[] decorators, boolean inner,
boolean enumer, BindingHolder holder) {
String actual = m_nameSet.add(name);
ClassHolder def = enumer ? new EnumerationClassHolder(actual, actual, this, holder, nconv, decorators, inner) :
(ClassHolder)new StructureClassHolder(actual, actual, this, holder, nconv, decorators, inner);
m_classes.add(def);
m_allClasses.add(def);
return def;
}
/**
* Add derived class to package. This method is only used when top-level classes are being used for substructures.
*
* @param name preferred name for class
* @param base base class name
* @param nconv name converter for class
* @param decorators class decorators
* @param enumer enumeration class flag
* @param holder binding holder
* @return class generator
*/
public ClassHolder addClass(String name, String base, NameConverter nconv, ClassDecorator[] decorators,
boolean enumer, BindingHolder holder) {
ClassHolder def = enumer ?
new EnumerationClassHolder(m_nameSet.add(name), base, this, holder, nconv, decorators, false) :
(ClassHolder)new StructureClassHolder(m_nameSet.add(name), base, this, holder, nconv, decorators, false);
m_classes.add(def);
m_allClasses.add(def);
return def;
}
/**
* Add an inner class to package.
*
* @param clas
*/
public void addInnerClass(IClassHolder clas) {
m_allClasses.add(clas);
}
/**
* Generate a specific class within this package. This first tests if the class has already been generated, and if
* it has does nothing.
*
* @param verbose
* @param clasdata class data
* @param ast
*/
public void generate(boolean verbose, TypeData clasdata, AST ast) {
if (!clasdata.isPregenerated()) {
ClassHolder clashold = (ClassHolder)clasdata;
if (!clashold.isGenerated()) {
// make sure the generate directory exists
if (m_generateDirectory != null) {
m_generateDirectory.mkdirs();
if (!m_generateDirectory.exists()) {
throw new IllegalStateException("Unable to create directory " + m_generateDirectory.getAbsolutePath());
}
}
// run the actual class generation
SourceBuilder builder = new SourceBuilder(ast, this, clashold.getName(), clashold.getImports());
clashold.generate(verbose, builder);
builder.finish(verbose);
}
}
}
/**
* Generate this package.
*
* @param verbose
* @param ast
* @param directory binding directory
*/
public void generate(boolean verbose, AST ast, BindingOrganizer directory) {
for (int i = 0; i < m_classes.size(); i++) {
ClassHolder clashold = (ClassHolder)m_classes.get(i);
generate(verbose, clashold, ast);
}
}
/**
* Get the field information for every class in this package. The returned pairs have the fully-qualified class name
* as the key, and the array of ordered field name and type string pairs as the values. This method is only
* meaningful after the class has been generated.
*
* @return class field information
*/
public StringObjectPair[] getClassFields() {
StringObjectPair[] pairs = new StringObjectPair[m_allClasses.size()];
for (int i = 0; i < m_allClasses.size(); i++) {
ClassHolder clas = (ClassHolder)m_allClasses.get(i);
pairs[i] = new StringObjectPair(clas.getFullName(), clas.getBuilder().getSortedFields());
}
Arrays.sort(pairs);
return pairs;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/Name.java 0000644 0001750 0001750 00000011611 10752422370 024240 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
/**
* Name representation for {@link Item} and related structures. Names may be shared between different levels of the item
* structure in some cases (such as an element that contains only a single value, with several layers of indirection),
* and this class supports name sharing while retaining the ability to modify the actual name text (necessary to avoid
* name conflicts in the generated code).
*
* @author Dennis M. Sosnoski
*/
public class Name
{
/** Flag for name fixed by user request. */
private final boolean m_fixed;
/** Name checked (and possibly adjusted) for conflicts flag. */
private boolean m_checked;
/** Actual name text. */
private String m_text;
/**
* Default constructor. This just creates a non-fixed name with no initial value.
*/
public Name() {
m_fixed = false;
}
/**
* Constructor.
*
* @param name fixed name text (null if not fixed)
*/
public Name(String name) {
m_text = name;
m_fixed = m_text != null;
}
/**
* Copy constructor.
*
* @param base
*/
public Name(Name base) {
m_fixed = base.m_fixed;
m_checked = base.m_checked;
m_text = base.m_text;
}
/**
* Check if name is fixed by configuration.
*
* @return true if fixed, false if not
*/
public boolean isFixed() {
return m_fixed;
}
/**
* Check if name has been checked for conflicts. This flag is used by the actual class generated code ({@link
* ClassHolder}) to track which names have already been entered into the set of names used by a class.
*
* @return checked
*/
public boolean isChecked() {
return m_checked;
}
/**
* Set flag for name checked for conflicts. This flag is used by the actual class generated code ({@link
* ClassHolder}) to track which names have already been entered into the set of names used by a class.
*
* @param checked
*/
public void setChecked(boolean checked) {
m_checked = checked;
}
/**
* Get item name.
*
* @return name (null if unspecified)
*/
public String getText() {
return m_text;
}
/**
* Set item name. It is an error to call this method if {@link #isFixed()} returns true.
*
* @param name (null if unspecified)
*/
public void setText(String name) {
if (m_fixed || name.indexOf('-') > 0) {
throw new IllegalStateException("Internal error - attempt to change configured name");
} else {
m_text = name;
}
}
/**
* Generate printable description of name. This is intended for use in logging output.
*
* @return description
*/
public String toString() {
StringBuffer buffer = new StringBuffer();
buffer.append('\'');
if (m_text == null) {
buffer.append("not set");
} else {
buffer.append(m_text);
}
buffer.append("' (");
if (m_fixed) {
buffer.append("fixed, ");
}
if (m_checked) {
buffer.append("checked, ");
}
buffer.append("id=");
buffer.append(hashCode());
buffer.append(')');
return buffer.toString();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/JavaType.java 0000644 0001750 0001750 00000025066 11171722574 025121 0 ustar twerner twerner /*
* Copyright (c) 2006-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
* Java types corresponding to schema types. The schema type list here should always match that in
* {@link org.jibx.schema.support.SchemaTypes}. As a special case, an instance of this class is also used to represent
* the special <any> schema component.
*
* @author Dennis M. Sosnoski
*/
public class JavaType
{
/** Predefined schema simple type correspondences (note not all are defined yet). */
private static final Map s_schemaTypesMap;
static {
// TODO define correspondences and add handling for current nulls
Map map = new HashMap();
addType("anySimpleType", "java.lang.String", map);
addType("anyURI", "java.lang.String", map);
addType("base64Binary", "byte[]", map);
addType("boolean", "boolean", "java.lang.Boolean", "org.jibx.runtime.Utility.ifBoolean", map);
addType("byte", "byte", "java.lang.Byte", "org.jibx.runtime.Utility.ifByte", map);
addType("date", null, "java.sql.Date", "org.jibx.runtime.Utility.ifDate", map);
addType("dateTime", null, "java.util.Date", "org.jibx.runtime.Utility.ifDateTime", map);
addType("decimal", "java.math.BigDecimal", map);
addType("double", "double", "java.lang.Double", map);
addType("duration", "java.lang.String", map);
addType("ENTITY", "java.lang.String", map);
addType("ENTITIES", "java.lang.String", map);
addType("float", "float", "java.lang.Float", map);
addType("gDay", "java.lang.String", map);
addType("gMonth", "java.lang.String", map);
addType("gMonthDay", "java.lang.String", map);
addType("gYear", "java.lang.String", map);
addType("gYearMonth", "java.lang.String", map);
addType("hexBinary", "byte[]", map);
addType("ID", "java.lang.String", map);
addType("IDREF", "java.lang.String", map);
addType("IDREFS", "java.lang.String", map);
addType("int", "int", "java.lang.Integer", "org.jibx.runtime.Utility.ifInt", map);
addType("integer", null, "java.math.BigInteger", "org.jibx.runtime.Utility.ifInteger", map);
addType("language", "java.lang.String", map);
addType("long", "long", "java.lang.Long", "org.jibx.runtime.Utility.ifLong", map);
addType("Name", "java.lang.String", map);
addType("negativeInteger", "java.lang.String", map);
addType("nonNegativeInteger", "java.lang.String", map);
addType("nonPositiveInteger", "java.lang.String", map);
addType("normalizedString", "java.lang.String", map);
addType("NCName", "java.lang.String", map);
addType("NMTOKEN", "java.lang.String", map);
addType("NMTOKENS", "java.lang.String", map);
addType("NOTATION", "java.lang.String", map);
addType("positiveInteger", "java.lang.String", map);
addType("QName", "org.jibx.runtime.QName", map);
addType("short", "short", "java.lang.Short", "org.jibx.runtime.Utility.ifShort", map);
addType("string", "java.lang.String", map);
addType("time", null, "java.sql.Time", "org.jibx.runtime.Utility.ifTime", map);
addType("token", "java.lang.String", map);
addType("unsignedByte", "java.lang.String", map);
addType("unsignedInt", "java.lang.String", map);
addType("unsignedLong", "java.lang.String", map);
addType("unsignedShort", "java.lang.String", map);
s_schemaTypesMap = Collections.unmodifiableMap(map); }
/** <any> schema component type. */
public static final JavaType s_anyType = new JavaType(null, null, "org.w3c.dom.Element");
/** <anyAttribute> schema component type. */
public static final JavaType s_anyAttributeType = new JavaType(null, null, "org.w3c.dom.Attribute");
/** Schema type local name (may be needed for special handling in binding - ID and IDREF, in particular). */
private final String m_schemaName;
/** Fully qualified primitive type name (null if none). */
private final String m_primitiveName;
/** Fully qualified object type name (non-null). */
private final String m_fqName;
/** JiBX format name (for types requiring special handling, null otherwise). */
private final String m_format;
/** Method to convert instance of type to a text string. */
private final String m_serializerMethod;
/** Method to convert text string to instance of type. */
private final String m_deserializerMethod;
/** Method to check if a text string matches the format for this type (null if unused). */
private final String m_checkMethod;
/**
* Constructor supporting special handling. This uses a string value for any types without specific Java equivalents
* defined.
*
* @param slname schema type local name
* @param pname primitive type name (null if none)
* @param fqname object type fully-qualified name (non-null)
* @param format JiBX format name (null if none)
* @param ser fully-qualified serializer class and method name (null if none)
* @param dser fully-qualified deserializer class and method name (null if none)
* @param check fully-qualified check class and method name (null if none)
*/
public JavaType(String slname, String pname, String fqname, String format, String ser, String dser, String check) {
if (fqname == null) {
throw new IllegalArgumentException("Internal error - object type required for definition");
}
m_schemaName = slname;
m_primitiveName = pname;
m_fqName = fqname;
m_format = format;
m_serializerMethod = ser;
m_deserializerMethod = dser;
m_checkMethod = check;
}
/**
* Basic constructor.
*
* @param slname schema type local name
* @param pname primitive type name (null if none)
* @param fqname object type fully-qualified name
*/
private JavaType(String slname, String pname, String fqname) {
this(slname, pname, fqname, null, null, null, null);
}
/**
* Helper method for adding object-only types to map.
*
* @param lname schema type local name
* @param fqname fully-qualified java object type name
*/
private static void addType(String lname, String fqname, Map map) {
addType(lname, null, fqname, null, map);
}
/**
* Helper method for adding types without check methods to map.
*
* @param lname schema type local name
* @param pname primitive type name (null if object type)
* @param fqname fully-qualified java object type name
*/
private static void addType(String lname, String pname, String fqname, Map map) {
addType(lname, null, fqname, null, map);
}
/**
* Helper method for creating instances and adding them to map.
*
* @param lname schema type local name
* @param pname primitive type name (null if object type)
* @param fqname fully-qualified java object type name (null if primitive type)
* @param check check method name (null if none)
*/
private static void addType(String lname, String pname, String fqname, String check, Map map) {
map.put(lname, new JavaType(lname, pname, fqname, null, null, null, check));
}
//
// Static access method
/**
* Get map from schema type local name to Java type.
*
* @return map
*/
public static Map getTypeMap() {
return s_schemaTypesMap;
}
//
// Access methods
/**
* Get schema type local name. This is only required because the binding generation needs to implement special
* handling for ID and IDREF values.
*
* @return schema type local name
*/
public String getSchemaName() {
return m_schemaName;
}
/**
* Get fully-qualified object type name.
*
* @return fully-qualified name
*/
public String getClassName() {
return m_fqName;
}
/**
* Get primitive type name.
*
* @return primitive type, null if none
*/
public String getPrimitiveName() {
return m_primitiveName;
}
/**
* Get format.
*
* @return format
*/
public String getFormat() {
return m_format;
}
/**
* Get serializer method name.
*
* @return name (null if none)
*/
public String getSerializerMethod() {
return m_serializerMethod;
}
/**
* Get deserializer method name.
*
* @return name (null if none)
*/
public String getDeserializerMethod() {
return m_deserializerMethod;
}
/**
* Get check method name.
*
* @return name (null if none)
*/
public String getCheckMethod() {
return m_checkMethod;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/ReferenceItem.java 0000644 0001750 0001750 00000020104 11167465000 026070 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.apache.log4j.Logger;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.codegen.custom.ComponentExtension;
import org.jibx.schema.elements.AnnotatedBase;
import org.jibx.schema.elements.SchemaBase;
/**
* Information for a reference to a global definition. The reference may be replaced with an inlined copy of the
* definition during code generation.
*
* @author Dennis M. Sosnoski
*/
public class ReferenceItem extends Item
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(GroupItem.class.getName());
/** Referenced type structure definition. */
private final DefinitionItem m_definition;
/**
* Copy constructor.
*
* @param original
* @param ref reference (for overrides to copy; null if none)
* @param parent
*/
private ReferenceItem(ReferenceItem original, Item ref, GroupItem parent) {
super(original, ref, original.getComponentExtension(), parent);
m_definition = original.m_definition;
}
/**
* Internal constructor for direct reference.
*
* @param comp schema component
* @param parent containing structure (null if a top-level structure)
* @param def referenced definition
*/
/*package*/ ReferenceItem(AnnotatedBase comp, GroupItem parent, DefinitionItem def) {
super(comp, parent);
m_definition = def;
def.countReference();
}
/**
* Internal constructor for converting group to reference. This is used when an embedded group is converted to a
* separate definition, as needed for class reuse.
*
* @param group
* @param def
*/
/*package*/ ReferenceItem(GroupItem group, DefinitionItem def) {
super(group, null, group.getComponentExtension(), group.getParent());
m_definition = def;
def.countReference();
}
/**
* Get the referenced structure.
*
* @return reference
*/
public DefinitionItem getDefinition() {
return m_definition;
}
/**
* Inline the referenced structure. This replaces the reference with a deep copy of the definition, copying the
* reference name and optional/repeated information over to the definition.
*
* @return replacement group
*/
public Item inlineReference() {
// This should not be necessary any more, since the group handling is supposed to give equivalent structure
// int type = comp.type();
// if (m_definition.getChildCount() == 1 &&
// (type == SchemaBase.ELEMENT_TYPE || type == SchemaBase.ATTRIBUTE_TYPE)) {
//
// // inlining attribute or element just substitutes the definition for the reference
// item = m_definition.getFirstChild().copy(this, getParent());
// if (s_logger.isDebugEnabled()) {
// s_logger.debug("Inlining reference to " + SchemaUtils.describeComponent(comp) +
// " using direct substitution");
// }
//
// } else {
// }
// decide which component to link to inlined group based on reference component type
AnnotatedBase refcomp = getSchemaComponent();
int type = refcomp.type();
ComponentExtension ext = (type == SchemaBase.ATTRIBUTE_TYPE || type == SchemaBase.ELEMENT_TYPE) ?
getComponentExtension() : m_definition.getComponentExtension();
// create new group from definition group
GroupItem group = new GroupItem(this, ext);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Inlining reference to " + SchemaUtils.describeComponent(m_definition.getSchemaComponent()) +
" from " + SchemaUtils.describeComponent(refcomp) + " as new group");
}
// replace this reference with the inlined group
getParent().replaceChild(this, group);
return group;
}
/**
* Copy the item under a different parent.
*
* @param ref reference (for overrides to copy; null if none)
* @param parent
* @return copy
*/
protected Item copy(Item ref, GroupItem parent) {
return new ReferenceItem(this, ref, parent);
}
/**
* Classify the content of this item as attribute, element, and/or character data content, and as requiring content
* of some form if appropriate. If this is an element or attribute reference the actual referencing component is
* used for classification purposes, since that will determine the classification. Otherwise, the actual definition
* is used as the source of the information.
*/
protected void classifyContent() {
int type = getSchemaComponent().type();
if (type == SchemaBase.ATTRIBUTE_TYPE || type == SchemaBase.ELEMENT_TYPE) {
// just use the actual component for classification
super.classifyContent();
} else {
// find the parent group with a different schema component
GroupItem parent = findDisjointParent();
if (parent != null) {
// assume the characteristics of the referenced definition
m_definition.classifyContent();
if (m_definition.isAttributePresent()) {
parent.forceAttributePresent();
}
if (m_definition.isElementPresent()) {
parent.forceElementPresent();
}
if (m_definition.isContentPresent()) {
parent.forceContentPresent();
}
if (!m_definition.isAllOptional()) {
parent.forceRequiredPresent();
}
}
}
}
/**
* Build a description of the reference.
*
* @param depth current nesting depth
* @param classified include classification details flag
* @return description
*/
protected String describe(int depth, boolean classified) {
StringBuffer buff = new StringBuffer(depth + 50);
buff.append(leadString(depth));
buff.append("reference to ");
if (m_definition.isInline()) {
buff.append("inlined ");
}
buff.append(SchemaUtils.describeComponent(m_definition.getSchemaComponent()));
buff.append(" with value name ");
buff.append(getName());
buff.append(": ");
buff.append(SchemaUtils.describeComponent(getSchemaComponent()));
buff.append('\n');
return buff.toString();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/ASTBuilderBase.java 0000644 0001750 0001750 00000010611 10752422370 026110 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.BodyDeclaration;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.NumberLiteral;
import org.eclipse.jdt.core.dom.StringLiteral;
/**
* Abstract syntax tree builder base class. This wraps the AST with convenience methods.
*
* @author Dennis M. Sosnoski
*/
public class ASTBuilderBase
{
/** Actual AST instance. */
protected final AST m_ast;
/**
* Constructor.
*
* @param ast
*/
public ASTBuilderBase(AST ast) {
m_ast = ast;
}
/**
* Set the public access flag for a declaration.
*
* @param decl
*/
public void setPublic(BodyDeclaration decl) {
decl.modifiers().add(m_ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));
}
/**
* Set the private access flag for a declaration.
*
* @param decl
*/
public void setPrivate(BodyDeclaration decl) {
decl.modifiers().add(m_ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));
}
/**
* Set the static flag for a declaration.
*
* @param decl
*/
public void setStatic(BodyDeclaration decl) {
decl.modifiers().add(m_ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));
}
/**
* Set the final flag for a declaration.
*
* @param decl
*/
public void setFinal(BodyDeclaration decl) {
decl.modifiers().add(m_ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));
}
/**
* Set declaration as private final.
*
* @param decl
*/
public void setPrivateFinal(BodyDeclaration decl) {
setPrivate(decl);
setFinal(decl);
}
/**
* Set declaration as private static final.
*
* @param decl
*/
public void setPrivateStaticFinal(BodyDeclaration decl) {
setPrivate(decl);
setStatic(decl);
setFinal(decl);
}
/**
* Set declaration as public static.
*
* @param decl
*/
public void setPublicStatic(BodyDeclaration decl) {
setPublic(decl);
setStatic(decl);
}
/**
* Set declaration as public static final.
*
* @param decl
*/
public void setPublicStaticFinal(BodyDeclaration decl) {
setPublic(decl);
setStatic(decl);
setFinal(decl);
}
/**
* Create a string literal.
*
* @param value literal value
* @return literal
*/
public StringLiteral stringLiteral(String value) {
StringLiteral literal = m_ast.newStringLiteral();
literal.setLiteralValue(value);
return literal;
}
/**
* Create a number literal.
*
* @param value literal value
* @return literal
*/
public NumberLiteral numberLiteral(String value) {
return m_ast.newNumberLiteral(value);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/StringPair.java 0000644 0001750 0001750 00000004023 10752422370 025441 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
/**
* Holder for a pair consisting of a key string and a value string.
*/
public class StringPair extends StringKeyed
{
/** String value. */
private final String m_value;
/**
* Constructor.
*
* @param key
* @param value
*/
public StringPair(String key, String value) {
super(key);
m_value = value;
}
/**
* Get the value string.
*
* @return value
*/
public String getValue() {
return m_value;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/StructureClassHolder.java 0000644 0001750 0001750 00000313277 11526033702 027516 0 ustar twerner twerner /*
* Copyright (c) 2006-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import org.apache.log4j.Logger;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.InfixExpression.Operator;
import org.jibx.binding.model.BindingHolder;
import org.jibx.binding.model.BuiltinFormats;
import org.jibx.binding.model.CollectionElement;
import org.jibx.binding.model.ContainerElementBase;
import org.jibx.binding.model.ElementBase;
import org.jibx.binding.model.FormatElement;
import org.jibx.binding.model.MappingElement;
import org.jibx.binding.model.MappingElementBase;
import org.jibx.binding.model.NestingAttributes;
import org.jibx.binding.model.PropertyAttributes;
import org.jibx.binding.model.StructureElement;
import org.jibx.binding.model.StructureElementBase;
import org.jibx.binding.model.ValueElement;
import org.jibx.runtime.QName;
import org.jibx.runtime.Utility;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.codegen.custom.NestingCustomBase;
import org.jibx.schema.codegen.custom.SchemaRootBase;
import org.jibx.schema.codegen.extend.ClassDecorator;
import org.jibx.schema.codegen.extend.NameConverter;
import org.jibx.schema.elements.AnnotatedBase;
import org.jibx.schema.elements.AttributeElement;
import org.jibx.schema.elements.CommonCompositorBase;
import org.jibx.schema.elements.ComplexTypeElement;
import org.jibx.schema.elements.ElementElement;
import org.jibx.schema.elements.SchemaBase;
import org.jibx.util.Types;
import org.jibx.util.UniqueNameSet;
/**
* Information for a data class to be included in code generated from schema.
*
* @author Dennis M. Sosnoski
*/
public class StructureClassHolder extends ClassHolder
{
private static final String LIST_DESERIALIZE_PREFIX = "deserialize";
private static final String LIST_SERIALIZE_PREFIX = "serialize";
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(StructureClassHolder.class.getName());
/** Default format definitions map. */
private static final Map s_formatMap;
static {
s_formatMap = new HashMap();
for (int i = 0; i < BuiltinFormats.s_builtinFormats.length; i++) {
FormatElement format = BuiltinFormats.s_builtinFormats[i];
s_formatMap.put(format.getTypeName(), format);
}
}
/** Flag for collection present in class. */
private boolean m_collectionPresent;
/** Root node for data structure of class. */
private ParentNode m_dataRoot;
/** Binding definition element for this class. */
private ContainerElementBase m_bindingElement;
/** Selection property names used in class (lazy create, null if none). */
protected UniqueNameSet m_selectSet;
/**
* Constructor.
*
* @param name class name
* @param base base class name
* @param pack package information
* @param holder binding holder
* @param nconv name converter
* @param decorators class decorators
* @param inner use inner classes for substructures
*/
public StructureClassHolder(String name, String base, PackageHolder pack, BindingHolder holder, NameConverter nconv,
ClassDecorator[] decorators, boolean inner) {
super(name, base, pack, holder, nconv, decorators, inner, false);
}
/**
* Constructor for creating a child inner class definition.
*
* @param name class name
* @param context parent class
*/
private StructureClassHolder(String name, StructureClassHolder context) {
super(name, context, false);
}
/**
* Derive group names from the containing group prefix and the simple name of the group.
*
* @param group
* @param container (null if none)
* @return name
*/
// static String deriveGroupName(GroupItem group, Group container) {
// String prefix = null;
// if (container != null) {
// prefix = group.getClassName();
// String prior = container.getPrefix();
// if (prior == null) {
// prefix = NameConverter.toNameLead(prefix);
// } else {
// prefix = prior + NameConverter.toNameWord(prefix);
// }
// prefix = container.uniqueChildPrefix(prefix);
// }
// return prefix;
// }
/**
* Populate a class data representation tree based on a supplied item tree. The mapping between the two trees is not
* one-to-one since item groupings may be ignored where irrelevant.
*
* @param struct root item in tree
* @param supertext schema documentation passed in for item tree
* @param parent containing data node
* @param bindhold associated binding definition holder
*/
private void addToTree(GroupItem struct, String supertext, ParentNode parent, BindingHolder bindhold) {
if (struct.getChildCount() > 1) {
supertext = null;
}
for (Item item = struct.getFirstChild(); item != null; item = item.getNext()) {
// first check for ignored group
if (item.isIgnored()) {
new ParentNode((GroupItem)item, parent);
} else {
// check for documentation available on schema component
String doctext = supertext;
if (item.isTopmost()) {
String curtext = extractDocumentation(item.getSchemaComponent());
if (curtext != null) {
doctext = curtext;
}
}
if (item.isCollection()) {
m_collectionPresent = true;
}
if (item instanceof GroupItem) {
GroupItem group = (GroupItem)item;
if (group.isInline()) {
if (group.getChildCount() > 0) {
// create a new group for an inlined compositor only if it's or or nested
ParentNode into = parent;
AnnotatedBase comp = item.getSchemaComponent();
if (comp instanceof CommonCompositorBase) {
if (comp.type() == SchemaBase.ALL_TYPE || comp.type() == SchemaBase.CHOICE_TYPE
|| comp.getParent() instanceof CommonCompositorBase) {
into = new ParentNode(group, parent);
into.setDocumentation(doctext);
doctext = null;
}
} else {
// create a new group for a non-compositor only if
// different schema component
if (struct.getSchemaComponent() != comp
&& group.getFirstChild().getSchemaComponent() != comp) {
into = new ParentNode(group, parent);
into.setDocumentation(doctext);
doctext = null;
}
}
addToTree(group, doctext, into, bindhold);
into.adjustName();
} else {
// just create parent node with no children matching group for optional empty grouping (so
// that it can be generated using a presence flag)
new ParentNode(group, parent);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Added empty parent for " +
SchemaUtils.describeComponent(group.getSchemaComponent()));
}
}
} else {
// create a new class and populate that
ClassHolder child;
String text = group.getEffectiveClassName();
if (m_useInnerClasses) {
if (m_nameSet.contains(text)) {
StructureClassHolder outer = this;
while (outer != null) {
if (outer.getName().equals(text)) {
text += "Inner";
break;
} else {
outer = (StructureClassHolder)outer.m_outerClass;
}
}
}
text = m_nameSet.add(text);
child = group.isEnumeration() ? new EnumerationClassHolder(text, this)
: (ClassHolder)new StructureClassHolder(text, this);
m_inners.add(child);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Added inner class " + child.getFullName());
}
} else {
String fullname = m_baseName + text;
child = m_package.addClass(fullname, m_baseName, m_nameConverter, m_decorators,
group.isEnumeration(), m_holder);
m_importsTracker.addImport(child.getFullName(), true);
text = child.getName();
if (group.isEnumeration()) {
FormatElement format = new FormatElement();
format.setTypeName(child.getBindingName());
((EnumerationClassHolder)child).setBinding(format);
bindhold.addFormat(format);
}
if (s_logger.isDebugEnabled()) {
s_logger.debug("Added derived class " + child.getFullName());
}
}
if (!group.isFixedClassName()) {
group.setClassName(text);
}
group.setGenerateClass(child);
DataNode value = new LeafNode(group, parent);
value.setDocumentation(doctext);
if (!group.isEnumeration()) {
group.convertTypeReference();
importValueType(value);
}
child.buildDataStructure(group, bindhold);
}
} else {
DataNode value = new LeafNode(item, parent);
value.setDocumentation(doctext);
importValueType(value);
}
}
}
}
/**
* Convert an item structure to a class representation. This may include creating subsidiary classes (either as
* inner classes, or as separate standalone classes), where necessary.
*
* @param group item group
* @param bindhold associated binding definition holder
*/
public void buildDataStructure(GroupItem group, BindingHolder bindhold) {
super.buildDataStructure(group, bindhold);
if (group.isEnumeration()) {
throw new IllegalArgumentException("Internal error - group is an enumeration");
} else {
// populate the actual definition structure
m_dataRoot = new ParentNode(group, null);
m_dataRoot.setDocumentation(extractDocumentation(group.getSchemaComponent()));
addToTree(group, null, m_dataRoot, bindhold);
// import the list type if needed
int reptype = getSchemaCustom().getRepeatType();
if ((reptype == SchemaRootBase.REPEAT_LIST || reptype == SchemaRootBase.REPEAT_TYPED) &&
m_collectionPresent) {
m_importsTracker.addImport(COLLECTION_VARIABLE_TYPE, false);
m_importsTracker.addImport(m_listImplClass, false);
}
}
}
/**
* Set the binding component linked to this class.
*
* @param container binding definition element (<mapping> or <structure>)
*/
public void setBinding(ContainerElementBase container) {
m_bindingElement = container;
}
/**
* Recursively add all inner enumeration classes as formats to a <mapping> definition. This is used to create the
* <format> elements for all nested enumerations, which need to be direct children of the <mapping> element
* for the top-level class.
*
* @param mapping
*/
private void addInnerFormats(MappingElementBase mapping) {
for (int i = 0; i < m_inners.size(); i++) {
ClassHolder inner = (ClassHolder)m_inners.get(i);
if (inner.isSimpleValue()) {
FormatElement format = new FormatElement();
format.setTypeName(inner.getBindingName());
((EnumerationClassHolder)inner).setBinding(format);
mapping.addTopChild(format);
} else {
((StructureClassHolder)inner).addInnerFormats(mapping);
}
}
}
/**
* Add all fixed names in a group to the set of names defined for this class. This calls itself recursively to
* handle nested groups.
*
* @param wrapper
*/
private void addFixedNames(ParentNode wrapper) {
ArrayList values = wrapper.getChildren();
for (int i = 0; i < values.size(); i++) {
DataNode value = (DataNode)values.get(i);
Item item = value.getItem();
boolean addname = item.isFixedName();
if (value instanceof ParentNode) {
ParentNode childgrp = (ParentNode)value;
addFixedNames(childgrp);
addname = addname && (childgrp.isSelectorNeeded() || wrapper.isSelectorNeeded());
}
if (addname) {
String name = item.getEffectiveName();
if (!m_nameSet.add(name).equals(name)) {
// TODO: pass in the validation context, create an error
throw new IllegalStateException("Name '" + name + "' cannot be used twice in same context");
}
}
}
}
/**
* Convert base name to collection name. If using a java.util.List representation the name is converted
* to singular form and "List" is appended; if using an array representation the name is converted to plural form.
*
* @param base
* @param item
*/
private void setCollectionName(String base, Item item) {
String name;
if (getSchemaCustom().getRepeatType() == SchemaRootBase.REPEAT_ARRAY) {
name = m_nameConverter.pluralize(base);
if (!name.equals(base)) {
s_logger.debug("Converted name " + base + " to " + name);
}
} else {
String singular = m_nameConverter.depluralize(base);
if (!singular.equals(base)) {
s_logger.debug("Converted name " + base + " to " + singular);
}
name = singular + "List";
}
item.setName(m_nameSet.add(name));
}
/**
* Handle value name assignments for a group within this class. This calls itself recursively to handle nested
* groups.
*
* @param parent
* @param innamed flag for parent group name already fixed
*/
private void fixFlexibleNames(ParentNode parent, boolean innamed) {
// check for group which uses a selector (choice or union)
String suffix = null;
ArrayList nodes = parent.getChildren();
if (parent.isSelectorNeeded()) {
// add the actual variable name used to record current state
Item item = parent.getItem();
item.setName(m_nameSet.add(m_nameConverter.toBaseName(item.getEffectiveName()) + "Select"));
// create value name set if first time used
if (m_selectSet == null) {
m_selectSet = new UniqueNameSet();
}
// generate constant for each child value
if (parent.getSchemaComponent().type() == SchemaBase.UNION_TYPE) {
suffix = "_Form";
} else {
suffix = "_Choice";
}
}
// handle name conversions and recording
for (int i = 0; i < nodes.size(); i++) {
DataNode node = (DataNode)nodes.get(i);
Item item = node.getItem();
String name = null;
if (node instanceof ParentNode) {
// use recursive call to set child group names (adopting name for group if same as first child, for
// group inside choice, in order to avoid adding the same name twice for non-conflicting usages); also
// adopt the child name if this is a collection, or if the first child is an implicit value, or if the
// group item is unnamed and there's only one child
ArrayList childvals = ((ParentNode)node).getChildren();
if (childvals.size() > 0) {
if (!item.isFixedName() && innamed) {
item.setName(parent.getItem().getName());
}
boolean passname = false;
if (childvals.size() == 1) {
// want to set the name at this level and pass it down when this is an element or attribute and
// there's only one child component all the way down to a leaf
passname = item.isFixedName() || innamed;
int type = item.getSchemaComponent().type();
if (!passname && (type == SchemaBase.ATTRIBUTE_TYPE ||
type == SchemaBase.ELEMENT_TYPE)) {
// check for single value all the way down
ArrayList childs = childvals;
boolean collect = node.isCollection();
while (childs.size() == 1) {
DataNode child = (DataNode)childs.get(0);
if (child.isCollection()) {
collect = true;
}
if (child instanceof LeafNode) {
// reached leaf with single path, so set name at current level and pass down
name = item.getEffectiveName();
if (collect) {
setCollectionName(name, item);
} else {
item.setName(m_nameSet.add(name));
}
passname = true;
break;
} else {
childs = ((ParentNode)child).getChildren();
}
}
}
}
fixFlexibleNames((ParentNode)node, passname);
}
} else if (item.isFixedName()) {
name = item.getName();
} else if (innamed) {
if (!item.isFixedName()) {
item.setName(parent.getItem().getName());
}
name = item.getName();
} else {
// convert and add the value name
name = item.getEffectiveName();
if (node.isCollection()) {
setCollectionName(name, item);
name = item.getName();
} else {
item.setName(m_nameSet.add(name));
}
}
// handle selection naming, if needed
if (parent.isSelectorNeeded()) {
if (name == null) {
name = item.getEffectiveName();
if (node.isCollection()) {
// pluralize name for collection, as will be done with the actual property name
// TODO: really need to use name structure and references, to avoid duplicated efforts like this
name = m_nameConverter.pluralize(name);
}
}
name = m_selectSet.add(NameUtils.toNameWord(name));
node.setSelectPropName(name);
node.setSelectConstName(m_nameConverter.toConstantName(name + suffix));
}
}
}
/**
* Generate the code to check and set the selection on any containing selector group. This should be used when
* setting any value, including inside selector methods (if used), since selector groups may be nested.
*
* @param value
* @param block
* @param builder
*/
private void generateSelectorSet(DataNode value, BlockBuilder block, ClassBuilder builder) {
ParentNode group;
while ((group = value.getParent()) != null) {
if (group.isSelectorNeeded()) {
int type = group.getSelectorType();
if (type == NestingCustomBase.SELECTION_CHECKEDSET || type == NestingCustomBase.SELECTION_CHECKEDBOTH) {
// when using select method call, just call that method (it will call containing group method, if
// any)
InvocationBuilder call = builder.createMemberMethodCall(group.getSelectSetMethod());
call.addVariableOperand(value.getSelectConstName());
block.addCall(call);
break;
} else {
// if setting directly, set this one and continue up to next containing group
block.addAssignVariableToField(value.getSelectConstName(), group.getSelectField());
}
}
value = group;
}
}
/**
* Generate the code to check the selection on any containing selector group. This should be used when getting any
* value, including inside selector methods (if used), since selector groups may be nested.
*
* @param value
* @param block
* @param builder
*/
private void generateSelectorCheck(DataNode value, BlockBuilder block, ClassBuilder builder) {
ParentNode group;
while ((group = value.getParent()) != null) {
if (group.isSelectorNeeded()) {
int type = group.getSelectorType();
if (type == NestingCustomBase.SELECTION_CHECKEDBOTH ||
type == NestingCustomBase.SELECTION_OVERRIDEBOTH) {
// when using select method call, just call that method (it will call containing group method, if
// any)
InvocationBuilder call = builder.createMemberMethodCall(group.getSelectCheckMethod());
call.addVariableOperand(value.getSelectConstName());
block.addCall(call);
break;
}
}
value = group;
}
}
/**
* Generate a test method for a value, if it's part of a group with a selector.
*
* @param node
* @param seldesc containing group description
* @param valdesc description of this value within group
* @param builder
*/
private void checkIfMethod(DataNode node, String seldesc, String valdesc, ClassBuilder builder) {
if (node.getParent().isSelectorNeeded()) {
MethodBuilder ifmeth = builder.addMethod("if" + node.getSelectPropName(), "boolean");
ifmeth.setPublic();
ifmeth.addSourceComment("Check if " + valdesc + " is current selection for " + seldesc + '.');
ifmeth.addSourceComment("");
ifmeth.addSourceComment("@return", " true if selection, false if not");
InfixExpressionBuilder testexpr = builder.buildNameOp(node.getParent().getSelectField(), Operator.EQUALS);
testexpr.addVariableOperand(node.getSelectConstName());
ifmeth.createBlock().addReturnExpression(testexpr);
}
}
/**
* Set the optional state of a structure or collection element in the binding. The name for the
* structure or collection must be set before calling this method, since the presence or absence of
* a name determines whether optional status is passed down from a parent.
*
* @param value node
* @param force optional state forced flag
* @param struct binding structure
*/
private void setStructureOptional(DataNode value, boolean force, StructureElementBase struct) {
boolean optional = value.isOptional();
if (!optional && struct.getName() == null) {
// no name for structure, so see if we can make the whole structure optional
Item item = value.getItem();
if (item instanceof GroupItem && item.isTopmost()) {
optional = ((GroupItem)item).isAllOptional();
} else if (getSchemaCustom().isStructureOptional() && item instanceof ReferenceItem) {
optional = ((ReferenceItem)item).getDefinition().isAllOptional();
}
}
if (optional) {
struct.setUsage(PropertyAttributes.OPTIONAL_USAGE);
}
}
/**
* Set the name and namespace URI for a <value> binding component. The value style must be set before making this
* call, since element and attribute elements are handled differently.
*
* @param qname qualified name to be set (null if none)
* @param holder binding containing the value definition
* @param value binding component
*/
private static void setName(QName qname, BindingHolder holder, ValueElement value) {
if (qname != null) {
if (value.getName() != null) {
throw new IllegalStateException("Internal error - trying to overwrite name '" + value.getName() + "' with '" + qname.getName() + '\'');
}
value.setName(qname.getName());
String uri = qname.getUri();
int style = value.getStyle();
if (style == NestingAttributes.ATTRIBUTE_STYLE) {
if (uri != null) {
holder.addNamespaceUsage(uri);
}
value.setUri(uri);
} else if (style == NestingAttributes.ELEMENT_STYLE) {
holder.addNamespaceUsage(uri);
if (!Utility.safeEquals(uri, holder.getElementDefaultNamespace())) {
value.setUri(uri);
}
}
}
}
/**
* Set the name and namespace URI for a <structure> or <collection> binding component.
*
* @param qname qualified name to be set (null if none)
* @param holder binding containing the structure or collection definition
* @param struct binding component
*/
private static void setName(QName qname, BindingHolder holder, StructureElementBase struct) {
if (qname != null) {
if (struct.getName() != null) {
throw new IllegalStateException("Internal error - trying to overwrite name '" + struct.getName() + "' with '" + qname.getName() + '\'');
}
String name = qname.getName();
String uri = qname.getUri();
if (name.charAt(0) == '{') {
int split = name.indexOf('}');
uri = name.substring(1, split);
name = name.substring(split+1);
}
struct.setName(name);
holder.addNamespaceUsage(uri);
if (!Utility.safeEquals(uri, holder.getElementDefaultNamespace())) {
struct.setUri(uri);
}
}
}
/**
* Build a <value> binding component for a field.
*
* @param node
* @param wrapname
* @param gname
* @param sname
* @param holder
* @return constructed binding component
*/
private ValueElement buildValueBinding(DataNode node, QName wrapname, String gname, String sname,
BindingHolder holder) {
// add element to binding structure for simple (primitive or text) value
ValueElement value = new ValueElement();
if (gname == null) {
value.setDeclaredType(node.getBindingType());
} else {
value.setGetName(gname);
value.setSetName(sname);
}
setValueHandlingOptions(node.getItem(), value, holder);
// set test method if needed to pick between alternatives
ParentNode wrapper = node.getParent();
if (wrapper.isSelectorNeeded()) {
value.setTestName("if" + node.getSelectPropName());
value.setUsage(PropertyAttributes.OPTIONAL_USAGE);
} else if (node.isOptional()) {
value.setUsage(PropertyAttributes.OPTIONAL_USAGE);
}
// get the schema component supplying an element or attribute name
AnnotatedBase comp = node.getSchemaComponent();
if (wrapname == null) {
// scan up structure to find parent linked to a different schema component
// TODO: find a better way to handle this in the node or item structures
ParentNode parent = wrapper;
while (parent != null && parent.getSchemaComponent() == comp) {
parent = parent.getParent();
}
// set name from node and style from component type
if (parent == null) {
// all parents linked to same component, treat as special case with name already set
value.setEffectiveStyle(ValueElement.TEXT_STYLE);
} else {
// name will have been passed down from containing element
// (since attributes handled directly)
if (comp.type() == SchemaBase.ELEMENT_TYPE) {
// value is an element, set the name directly
value.setEffectiveStyle(NestingAttributes.ELEMENT_STYLE);
ElementElement elem = (ElementElement)comp;
if (SchemaUtils.isOptionalElement(elem)) {
// TODO: this is needed because the optional status doesn't inherit downward for embedded items,
// as when a simpleType is nested inside an optional attribute. should the code be changed to
// inherit instead?
value.setUsage(PropertyAttributes.OPTIONAL_USAGE);
}
} else if (comp.type() == SchemaBase.ATTRIBUTE_TYPE) {
// value is an attribute, set the name directly
value.setEffectiveStyle(NestingAttributes.ATTRIBUTE_STYLE);
AttributeElement attr = (AttributeElement)comp;
if (SchemaUtils.isOptionalAttribute(attr)) {
// TODO: this is needed because the optional status doesn't inherit downward for embedded items, as
// when a simpleType is nested inside an optional attribute. should the code be changed to
// inherit instead?
value.setUsage(PropertyAttributes.OPTIONAL_USAGE);
}
} else {
value.setEffectiveStyle(ValueElement.TEXT_STYLE);
}
setName(node.getQName(), holder, value);
}
} else {
value.setEffectiveStyle(NestingAttributes.ELEMENT_STYLE);
setName(wrapname, holder, value);
}
return value;
}
/**
* Set the field and get/set access method names for a property.
*
* @param basename
* @param node
*/
private void setMemberNames(String basename, DataNode node) {
// define the field and get/set names
String propname = node.getPropName();
s_logger.debug("Adding property " + propname);
node.setFieldName(m_nameConverter.toFieldName(m_nameConverter.toBaseName(propname)));
String getpref = "boolean".equals(node.getType()) ? "is" : "get";
node.setGetMethodName(getpref + propname);
node.setSetMethodName("set" + propname);
}
/**
* Add a simple property to the class. This adds the actual field definition, along with the appropriate access
* methods.
*
* @param basename
* @param node
* @param builder
*/
private void addSimpleProperty(String basename, DataNode node, ClassBuilder builder) {
// set the field and method names
setMemberNames(basename, node);
// make sure the type is defined
String type = node.getType();
if (type == null) {
// type can be null in case of xs:any with discard handling, but otherwise invalid
if (node.isAny()) {
return;
} else {
throw new IllegalStateException("Internal error - no type for property");
}
}
if (s_logger.isDebugEnabled()) {
s_logger.debug("Found type " + type + " for property " + basename);
}
// generate the field as a simple value
String fname = node.getFieldName();
FieldBuilder field = builder.addField(fname, type);
field.setPrivate();
// add get method definition (unchecked, but result meaningless if not the selected group item)
MethodBuilder getmeth = builder.addMethod(node.getGetMethodName(), type);
getmeth.setPublic();
StringBuffer buff = new StringBuffer();
buff.append("Get the ");
String descript = describe(node);
buff.append(descript);
buff.append(" value.");
String document = findDocumentation(false, node);
if (document != null) {
buff.append(' ');
buff.append(document);
}
getmeth.addSourceComment(buff.toString());
getmeth.addSourceComment("");
getmeth.addSourceComment("@return", " value");
BlockBuilder block = getmeth.createBlock();
generateSelectorCheck(node, block, builder);
block.addReturnNamed(fname);
// add the set method definition
MethodBuilder setmeth = builder.addMethod(node.getSetMethodName(), "void");
setmeth.setPublic();
buff.replace(0, 3, "Set");
setmeth.addSourceComment(buff.toString());
setmeth.addSourceComment("");
String nonres = NameUtils.convertReserved(basename);
setmeth.addSourceComment("@param", " " + nonres);
setmeth.addParameter(nonres, type);
block = setmeth.createBlock();
generateSelectorSet(node, block, builder);
block.addAssignVariableToField(nonres, fname);
// call decorators for added value processing
for (int i = 0; i < m_decorators.length; i++) {
m_decorators[i].valueAdded(nonres, false, type, field.getDeclaration(), getmeth.getDeclaration(),
setmeth.getDeclaration(), descript, this);
}
}
/**
* Add a multiple-valued property to the class. This adds the actual field definition, along with the appropriate
* access methods.
*
* @param basename
* @param node
* @param builder
*/
private void addRepeatedProperty(String basename, DataNode node, ClassBuilder builder) {
// set up the member names
String propname = node.getPropName();
setMemberNames(basename, node);
// find the basic value type (which may require digging down to the leaf node, for a complex collection)
String basetype;
int collcount = node.isCollection() ? 1 : 0;
DataNode nested = node;
while ((basetype = nested.getType()) == null && nested.isInterior() &&
((ParentNode)nested).getChildren().size() > 0) {
nested = (DataNode)((ParentNode)nested).getChildren().get(0);
if (nested.isCollection()) {
collcount++;
}
}
if (basetype == null) {
// type can be null in case of xs:any with discard handling, but otherwise invalid
if (node.isAny()) {
return;
} else {
basetype = "java.lang.String";
}
}
if (s_logger.isDebugEnabled()) {
s_logger.debug("Found type " + basetype + " (" + collcount + " layers of collection nesting) for property "
+ propname);
}
// find the types to be used for field and actual instance
String type;
Type fieldtype;
Type insttype;
int reptype = getSchemaCustom().getRepeatType();
if (reptype == SchemaRootBase.REPEAT_TYPED) {
fieldtype = builder.createParameterizedType(COLLECTION_VARIABLE_TYPE, basetype);
insttype = builder.createType(basetype);
while (--collcount > 0) {
fieldtype = builder.createParameterizedType(COLLECTION_VARIABLE_TYPE, fieldtype);
insttype = builder.createParameterizedType(COLLECTION_VARIABLE_TYPE, insttype);
}
type = basetype;
insttype = builder.createParameterizedType(m_listImplClass, insttype);
} else if (reptype == SchemaRootBase.REPEAT_LIST || node.isAny()) {
fieldtype = builder.createType(COLLECTION_VARIABLE_TYPE);
insttype = builder.createType(m_listImplClass);
if (collcount > 1) {
type = COLLECTION_VARIABLE_TYPE;
} else {
type = basetype;
}
} else {
type = basetype;
while (--collcount > 0) {
type += "[]";
}
fieldtype = builder.createType(type + "[]");
insttype = null;
}
// get documentation and description text
String document = findDocumentation(true, node);
String descript = describe(node);
String term = getSchemaCustom().getRepeatType() == SchemaRootBase.REPEAT_ARRAY ? "array" : "list";
// generate the field as a collection
String fname = node.getFieldName();
FieldBuilder field = builder.addField(fname, fieldtype);
if (insttype != null) {
field.setInitializer(builder.newInstance(insttype));
}
field.setPrivate();
// add get method definition (unchecked, but result meaningless if not the selected group item)
MethodBuilder getmeth = builder.addMethod(node.getGetMethodName(), (Type)builder.clone(fieldtype));
getmeth.setPublic();
StringBuffer buff = new StringBuffer();
buff.append("Get the ");
buff.append(term);
buff.append(" of ");
buff.append(descript);
buff.append(" items.");
if (document != null) {
buff.append(' ');
buff.append(document);
}
getmeth.addSourceComment(buff.toString());
getmeth.addSourceComment("");
getmeth.addSourceComment("@return", " " + term);
getmeth.createBlock().addReturnNamed(fname);
// add the set method definition
MethodBuilder setmeth = builder.addMethod(node.getSetMethodName(), "void");
setmeth.setPublic();
buff.replace(0, 3, "Set");
setmeth.addSourceComment(buff.toString());
setmeth.addSourceComment("");
setmeth.addSourceComment("@param", " " + COLLECTION_VARIABLE_NAME);
setmeth.addParameter(COLLECTION_VARIABLE_NAME, (Type)builder.clone(fieldtype));
BlockBuilder block = setmeth.createBlock();
generateSelectorSet(node, block, builder);
block.addAssignVariableToField(COLLECTION_VARIABLE_NAME, fname);
// process list and collection differently for binding
Item item = node.getItem();
if (!node.isCollection()) {
// determine format conversion handling for type
String valsername = null;
String valdesername = null;
String valuename = null;
FormatElement format = (FormatElement)s_formatMap.get(type);
boolean passctx = false;
if (format != null) {
valsername = format.getSerializerName();
valdesername = format.getDeserializerName();
if (valsername == null && !"java.lang.String".equals(type)) {
valuename = "toString";
}
passctx = "org.jibx.runtime.QName".equals(type);
} else if (item instanceof ReferenceItem) {
DefinitionItem def = ((ReferenceItem)item).getDefinition();
if (def.isEnumeration()) {
EnumerationClassHolder genclas = (EnumerationClassHolder)def.getGenerateClass();
valsername = EnumerationClassHolder.CONVERTFORCE_METHOD;
valuename = genclas.getName() + ".toString";
}
} else {
throw new IllegalStateException("Internal error - invalid list type");
}
// add list serializer method to class
String sername = LIST_SERIALIZE_PREFIX + propname;
MethodBuilder sermeth = builder.addMethod(sername, "java.lang.String");
sermeth.addParameter("values", (Type)builder.clone(fieldtype));
if (passctx) {
SingleVariableDeclaration decl = sermeth.addParameter("ictx", "org.jibx.runtime.IMarshallingContext");
decl.modifiers().add(decl.getAST().newModifier(Modifier.ModifierKeyword.FINAL_KEYWORD));
sermeth.addThrows("org.jibx.runtime.JiBXException");
}
sermeth.setPublicStatic();
sermeth.addSourceComment("Serializer for " + descript + ' ' + term + '.');
sermeth.addSourceComment("");
sermeth.addSourceComment("@param", " values");
sermeth.addSourceComment("@return", " text");
// create a simple null return for null parameter string
BlockBuilder nullblock = builder.newBlock();
nullblock.addReturnNull();
// create block for actual serialization when parameter non-null
BlockBuilder serblock = builder.newBlock();
NewInstanceBuilder newbuff = builder.newInstance("java.lang.StringBuffer");
serblock.addLocalVariableDeclaration("java.lang.StringBuffer", "buff", newbuff);
// create body of loop to handle the conversion
BlockBuilder forblock = builder.newBlock();
// append space to buffer unless empty
InfixExpressionBuilder lengthexpr = builder.buildInfix(Operator.GREATER);
lengthexpr.addOperand(builder.createNormalMethodCall("buff", "length"));
lengthexpr.addNumberLiteralOperand("0");
InvocationBuilder appendcall = builder.createNormalMethodCall("buff", "append");
appendcall.addCharacterLiteralOperand(' ');
BlockBuilder spaceblock = builder.newBlock();
spaceblock.addExpressionStatement(appendcall);
forblock.addIfStatement(lengthexpr, spaceblock);
// load the current value from array
if (reptype == SchemaRootBase.REPEAT_TYPED) {
forblock.addLocalVariableDeclaration(type, "value", builder.createNormalMethodCall("iter", "next"));
} else if (reptype == SchemaRootBase.REPEAT_LIST) {
CastBuilder castexpr = builder.buildCast(type);
castexpr.addOperand(builder.createNormalMethodCall("iter", "next"));
forblock.addLocalVariableDeclaration(type, "value", castexpr);
} else {
forblock.addLocalVariableDeclaration(type, "value", builder.buildArrayIndexAccess("values", "index"));
}
// append the current value to the buffer
appendcall = builder.createNormalMethodCall("buff", "append");
if (valuename != null) {
appendcall.addOperand(builder.createNormalMethodCall("value", valuename));
} else if (valdesername != null) {
InvocationBuilder sercall = builder.createStaticMethodCall(valsername);
sercall.addVariableOperand("value");
if (passctx) {
sercall.addVariableOperand("ictx");
}
appendcall.addOperand(sercall);
} else {
appendcall.addVariableOperand("value");
}
forblock.addExpressionStatement(appendcall);
// build the for loop around the conversion
if (reptype == SchemaRootBase.REPEAT_TYPED) {
Type itertype = builder.createParameterizedType("java.util.Iterator", type);
serblock.addIteratedForStatement("iter", itertype,
builder.createNormalMethodCall("values", "iterator"), forblock);
} else if (reptype == SchemaRootBase.REPEAT_LIST) {
serblock.addIteratedForStatement("iter", builder.createType("java.util.Iterator"),
builder.createNormalMethodCall("values", "iterator"), forblock);
} else {
serblock.addIndexedForStatement("index", "values", forblock);
}
// finish non-null serialization block with buffer conversion
serblock.addReturnExpression(builder.createNormalMethodCall("buff", "toString"));
// finish with the if statement that decides which to execute
InfixExpressionBuilder iftest = builder.buildNameOp("values", Operator.EQUALS);
iftest.addNullOperand();
sermeth.createBlock().addIfElseStatement(iftest, nullblock, serblock);
// add list deserializer method to class
String desername = LIST_DESERIALIZE_PREFIX + propname;
MethodBuilder desermeth = builder.addMethod(desername, (Type)builder.clone(fieldtype));
desermeth.addParameter("text", "java.lang.String");
if (passctx) {
SingleVariableDeclaration decl = desermeth.addParameter("ictx",
"org.jibx.runtime.IUnmarshallingContext");
decl.modifiers().add(decl.getAST().newModifier(Modifier.ModifierKeyword.FINAL_KEYWORD));
}
desermeth.setPublicStatic();
desermeth.addSourceComment("Deserializer for " + descript + ' ' + term + '.');
desermeth.addSourceComment("");
desermeth.addSourceComment("@param", " text");
desermeth.addSourceComment("@return", " values");
desermeth.addSourceComment("@throws", " org.jibx.runtime.JiBXException on conversion error");
desermeth.addThrows("org.jibx.runtime.JiBXException");
block = desermeth.createBlock();
// build instance creation for anonymous inner class to handle deserialization
NewInstanceBuilder newinst = builder.newInstance("org.jibx.runtime.IListItemDeserializer");
ClassBuilder anonclas = newinst.addAnonymousInnerClass();
MethodBuilder innermeth = anonclas.addMethod("deserialize", "java.lang.Object");
if (passctx) {
innermeth.addThrows("org.jibx.runtime.JiBXException");
}
innermeth.addParameter("text", "java.lang.String");
innermeth.setPublic();
BlockBuilder innerblock = innermeth.createBlock();
if (valdesername == null) {
innerblock.addReturnNamed("text");
} else {
InvocationBuilder desercall = builder.createStaticMethodCall(valdesername);
desercall.addVariableOperand("text");
if (passctx) {
desercall.addVariableOperand("ictx");
}
innerblock.addReturnExpression(desercall);
}
block.addLocalVariableDeclaration("org.jibx.runtime.IListItemDeserializer", "ldser", newinst);
// build call using anonymous inner class to deserialize to untyped collection
InvocationBuilder desercall = builder.createStaticMethodCall("org.jibx.runtime.Utility.deserializeList");
desercall.addVariableOperand("text");
desercall.addVariableOperand("ldser");
// handle the return as appropriate
if (reptype == SchemaRootBase.REPEAT_TYPED) {
CastBuilder castexpr = builder.buildCast((Type)builder.clone(fieldtype));
castexpr.addOperand(desercall);
block.addReturnExpression(castexpr);
} else if (reptype == SchemaRootBase.REPEAT_LIST) {
block.addReturnExpression(desercall);
} else {
// save deserialization result list to local variable
block.addLocalVariableDeclaration("java.util.List", "list", desercall);
// create null return block
BlockBuilder ifnull = builder.newBlock();
ifnull.addReturnNull();
// create non-null return with conversion to array
BlockBuilder ifnonnull = builder.newBlock();
InvocationBuilder toarraycall = builder.createNormalMethodCall("list", "toArray");
NewArrayBuilder newarray = builder.newArrayBuilder(type);
newarray.setSize(builder.createNormalMethodCall("list", "size"));
toarraycall.addOperand(newarray);
CastBuilder castexpr = builder.buildCast((Type)builder.clone(fieldtype));
castexpr.addOperand(toarraycall);
ifnonnull.addReturnExpression(castexpr);
// finish with the if statement that decides which to execute
iftest = builder.buildNameOp("list", Operator.EQUALS);
iftest.addNullOperand();
block.addIfElseStatement(iftest, ifnull, ifnonnull);
}
}
// call decorators for added value processing
for (int i = 0; i < m_decorators.length; i++) {
m_decorators[i].valueAdded(basename, true, basetype, field.getDeclaration(), getmeth.getDeclaration(),
setmeth.getDeclaration(), descript, this);
}
}
/**
* Add a flag property to the class. This adds the actual field definition, along with the appropriate access
* methods.
*
* @param basename
* @param node
* @param builder
*/
private void addFlagProperty(String basename, DataNode node, ClassBuilder builder) {
// define the flag field and method names
String propname = node.getPropName();
s_logger.debug("Adding property " + propname);
String fname = m_nameConverter.toFieldName(basename);
node.setFieldName(fname);
node.setTestMethodName("if" + propname + "Present");
node.setFlagMethodName("flag" + propname + "Present");
String nonres = NameUtils.convertReserved(basename);
// generate the field as a simple boolean value
FieldBuilder field = builder.addField(fname, "boolean");
field.setPrivate();
// add test method definition
MethodBuilder testmeth = builder.addMethod(node.getTestMethodName(), "boolean");
testmeth.setPublic();
StringBuffer buff = new StringBuffer();
buff.append("Check if the ");
String descript = describe(node);
buff.append(descript);
buff.append(" is present.");
String document = findDocumentation(false, node);
if (document != null) {
buff.append(' ');
buff.append(document);
}
testmeth.addSourceComment(buff.toString());
testmeth.addSourceComment("");
testmeth.addSourceComment("@return", " true if present, false if not");
BlockBuilder block = testmeth.createBlock();
generateSelectorCheck(node, block, builder);
block.addReturnNamed(fname);
// add the flag method definition
MethodBuilder flagmeth = builder.addMethod(node.getFlagMethodName(), "void");
flagmeth.setPublic();
buff.setLength(0);
buff.append("Set flag for ");
buff.append(descript);
buff.append(" present.");
if (document != null) {
buff.append(' ');
buff.append(document);
}
flagmeth.addSourceComment(buff.toString());
flagmeth.addSourceComment("");
flagmeth.addSourceComment("@param", " " + nonres);
flagmeth.addParameter(nonres, "boolean");
block = flagmeth.createBlock();
generateSelectorSet(node, block, builder);
block.addAssignVariableToField(nonres, fname);
// call decorators for added value processing
for (int i = 0; i < m_decorators.length; i++) {
m_decorators[i].valueAdded(nonres, false, "boolean", field.getDeclaration(), null, null, descript, this);
}
}
/**
* Find the schema documentation associated with a data node. If the node has documentation set and does not have a
* separate class, this just returns the documentation from that node. Otherwise, it moves up the node tree until it
* finds a documented node, terminating if any parent has more than one child or when it reaches the node matching
* the root of the class data structure.
*
* @param top use topmost documentation found flag
* @param node starting node
* @return documentation
*/
private String findDocumentation(boolean top, DataNode node) {
// first check if separate class for node (in which case documentation goes with class)
Item item = node.getItem();
if (item instanceof GroupItem && ((GroupItem)item).getGenerateClass() != null) {
node = node.getParent();
}
// scan for documentation which can be used for node
String text = null;
while (node != m_dataRoot) {
String thisdoc = node.getDocumentation();
if (thisdoc != null) {
text = thisdoc;
if (!top) {
break;
}
}
ParentNode parent = node.getParent();
if (parent.getChildren().size() == 1) {
node = parent;
} else {
break;
}
}
return text;
}
/**
* Generate the fields and methods for a wrapper around one or more properties. This calls itself recursively to
* handle nested wrappers.
*
* @param parent
*/
private void addToClass(ParentNode parent) {
// first check if grouping requires a selector field
ClassBuilder builder = getBuilder();
ArrayList nodes = parent.getChildren();
Item grpitem = parent.getItem();
String seldesc = null;
if (parent.isSelectorNeeded()) {
// build the selector field
String basename = grpitem.getEffectiveName();
String fieldname = m_nameConverter.toFieldName(basename);
parent.setSelectField(fieldname);
builder.addIntField(fieldname, "-1").setPrivate();
// build the basic description information
AnnotatedBase comp = parent.getSchemaComponent();
StringBuffer buff = new StringBuffer();
if (parent.getQName() != null) {
buff.append(parent.getQName().getName());
buff.append(' ');
}
String descript;
if (comp.type() == SchemaBase.UNION_TYPE) {
descript = "form";
buff.append("union");
} else {
descript = "choice";
buff.append("choice");
}
seldesc = buff.toString();
buff.insert(0, "Clear the ");
buff.append(" selection.");
// create constants for each alternative value
String namesuffix = NameUtils.toNameWord(basename);
boolean expose = parent.isSelectorExposed();
int index = 0;
for (int i = 0; i < nodes.size(); i++) {
DataNode node = (DataNode)nodes.get(i);
if (!node.isIgnored()) {
FieldBuilder field = builder.addIntField(node.getSelectConstName(), Integer.toString(index++));
if (expose) {
field.setPublicStaticFinal();
field.addSourceComment(namesuffix + " value when " + node.getItem().getEffectiveName() +
" is set");
} else {
field.setPrivateStaticFinal();
}
}
}
// check for selector set methods used
int seltype = parent.getSelectorType();
// add the selector set method
String selectname = "set" + namesuffix;
String resetname = "clear" + namesuffix;
parent.setSelectSetMethod(selectname);
MethodBuilder setmeth = builder.addMethod(selectname, "void");
setmeth.setPrivate();
BlockBuilder block = setmeth.createBlock();
setmeth.addParameter(descript, "int");
// start by setting any containing selectors
generateSelectorSet(parent, block, builder);
// check for state check needed on set
if (seltype == NestingCustomBase.SELECTION_OVERRIDESET ||
seltype == NestingCustomBase.SELECTION_OVERRIDEBOTH) {
// set overrides prior state, just set new state directly
block.addAssignVariableToField(descript, fieldname);
} else {
// create the set block for when there's no current choice
BlockBuilder assignblock = builder.newBlock();
assignblock.addAssignVariableToField(descript, fieldname);
// create the exception thrown when choice does not match current setting
BlockBuilder throwblock = builder.newBlock();
throwblock.addThrowException("IllegalStateException", "Need to call " + resetname
+ "() before changing existing " + descript);
// finish with the if statement that decides which to execute
InfixExpressionBuilder iftest = builder.buildNameOp(fieldname, Operator.EQUALS);
iftest.addNumberLiteralOperand("-1");
InfixExpressionBuilder elsetest = builder.buildNameOp(fieldname, Operator.NOT_EQUALS);
elsetest.addVariableOperand(descript);
block.addIfElseIfStatement(iftest, elsetest, assignblock, throwblock);
}
// check for state check needed on get
if (seltype == NestingCustomBase.SELECTION_CHECKEDBOTH ||
seltype == NestingCustomBase.SELECTION_OVERRIDEBOTH) {
// add the selector check method
String checkname = "check" + namesuffix;
parent.setSelectCheckMethod(checkname);
MethodBuilder checkmeth = builder.addMethod(checkname, "void");
checkmeth.setPrivate();
block = checkmeth.createBlock();
checkmeth.addParameter(descript, "int");
// start by setting any containing selectors
generateSelectorCheck(parent, block, builder);
// create the exception thrown when current state is wrong
BlockBuilder throwblock = builder.newBlock();
InfixExpressionBuilder strcat = builder.buildStringConcatenation("State mismatch when accessing " +
descript + " value: current state is ");
strcat.addVariableOperand(fieldname);
throwblock.addThrowException("IllegalStateException", strcat);
// finish with the if statement that decides which to execute
InfixExpressionBuilder unequaltest = builder.buildNameOp(fieldname, Operator.NOT_EQUALS);
unequaltest.addVariableOperand(descript);
InfixExpressionBuilder unsettest = builder.buildNameOp(fieldname, Operator.NOT_EQUALS);
unsettest.addNumberLiteralOperand("-1");
InfixExpressionBuilder iftest = builder.buildInfix(Operator.CONDITIONAL_AND);
iftest.addOperand(unequaltest);
iftest.addOperand(unsettest);
block.addIfStatement(iftest, throwblock);
}
// add selector clear method (public, so documented)
MethodBuilder resetmeth = builder.addMethod(resetname, "void");
resetmeth.setPublic();
resetmeth.addSourceComment(buff.toString());
block = resetmeth.createBlock();
block.addAssignToName(block.numberLiteral("-1"), fieldname);
// add state check method if needed
if (expose) {
MethodBuilder statemethod = builder.addMethod("state" + namesuffix, "int");
statemethod.setPublic();
statemethod.addSourceComment("Get the current " + seldesc + " state.");
statemethod.addSourceComment("@return", " state");
statemethod.createBlock().addReturnNamed(fieldname);
}
if (s_logger.isDebugEnabled()) {
s_logger.debug("Created selector for grouping component "
+ SchemaUtils.describeComponent(grpitem.getSchemaComponent()) + " in class " + getFullName());
}
}
// generate all values in group
for (int i = 0; i < nodes.size(); i++) {
// check if there's a separate value for this child node
DataNode node = (DataNode)nodes.get(i);
Item item = node.getItem();
if (!node.isIgnored() && !item.isImplicit()) {
// get the base name and property name to be used for item
boolean repeat = node.isCollection() || node.isList();
String basename = item.getEffectiveName();
String workingname = basename;
if (repeat) {
String plural = m_nameConverter.pluralize(workingname);
if (!plural.equals(workingname)) {
workingname = m_nameSet.add(plural);
}
}
String propname = NameUtils.toNameWord(workingname);
node.setPropName(propname);
// generate test method, if inside selector group
checkIfMethod(node, seldesc, propname, builder);
// handle wrapper or simple property as appropriate
if (node.isInterior()) {
ParentNode nestedparent = (ParentNode)node;
if (nestedparent.isCollection()) {
// add property matching this node
addRepeatedProperty(basename, nestedparent, builder);
} else if (nestedparent.getChildren().size() == 0) {
if (nestedparent.isOptional() || parent.isSelectorNeeded()) {
// empty branch of tree, just add a boolean flag to indicate presence
addFlagProperty(basename, nestedparent, builder);
}
} else {
// just process nesting directly
addToClass(nestedparent);
}
} else {
// add property matching this node
if (repeat) {
addRepeatedProperty(basename, node, builder);
} else {
addSimpleProperty(basename, node, builder);
}
}
}
}
}
/**
* Build the binding structure element for a reference to a class.
*
* @param leaf reference node
* @param def target definition
* @param single flag for single child
* @param holder holder for binding definition
* @param bindcomp containing binding element
* @return binding structure
*/
private StructureElement addReferenceStructure(LeafNode leaf, DefinitionItem def, boolean single,
BindingHolder holder, ContainerElementBase bindcomp) {
// first check if a new structure element is needed in the binding for the reference
StructureElement struct = null;
boolean keep = false;
int type = leaf.getSchemaComponent().type();
if (single && bindcomp instanceof StructureElement) {
struct = (StructureElement)bindcomp;
keep = struct.getGetName() == null && struct.getSetName() == null && struct.getFieldName() == null &&
!struct.isChoice() && struct.getDeclaredType() == null && struct.getMapAsQName() == null &&
(struct.getName() == null || (type != SchemaBase.ATTRIBUTE_TYPE && type != SchemaBase.ELEMENT_TYPE));
}
if (!keep) {
struct = new StructureElement();
}
if (def.getSchemaComponent().type() == SchemaBase.ELEMENT_TYPE) {
// element definition reference, invoke concrete mapping by class name
struct.setDeclaredType(leaf.getBindingType());
} else {
// not an element reference, so map by abstract mapping 'type' name (which may or may not be a type)
QName qname = def.getQName();
String uri = qname.getUri();
if (uri != null) {
holder.addTypeNameReference(uri, def.getSchemaComponent().getSchema());
}
struct.setMapAsQName(qname);
}
return struct;
}
/**
* Create a new collection element for the binding. This initializes the create and declared types of the
* collection as appropriate, along with the wrapper name and optional status.
*
* @param wrapname name to be used for wrapper collection or structure, null if none
* @param wrapopt wrapper element optional flag (should be false if wrapname is null)
* @param holder binding definition tracking information
* @param node data node associated with collection
* @return collection element
*/
private CollectionElement newCollection(QName wrapname, boolean wrapopt, BindingHolder holder, DataNode node) {
CollectionElement collect = new CollectionElement();
int reptype = getSchemaCustom().getRepeatType();
boolean list = reptype == SchemaRootBase.REPEAT_LIST || reptype == SchemaRootBase.REPEAT_TYPED;
if (list) {
collect.setCreateType(m_listImplClass);
}
if (wrapname == null) {
if (node.isOptional()) {
collect.setUsage(PropertyAttributes.OPTIONAL_USAGE);
}
} else {
setName(wrapname, holder, collect);
if (wrapopt) {
collect.setUsage(PropertyAttributes.OPTIONAL_USAGE);
}
}
return collect;
}
/**
* Set serializer/deserializer options for a <value> component of the binding. If the item defining the item is a
* reference, this uses the definition type name as the format and makes sure the definition namespace is defined
* within the binding being generated. If the item defining the item is a builtin type, this sets the format and/or
* serializer/deserializer methods based on the type definition.
*
* @param item
* @param value
* @param holder
*/
private void setValueHandlingOptions(Item item, ValueElement value, BindingHolder holder) {
if (item instanceof ReferenceItem) {
ReferenceItem refitem = (ReferenceItem)item;
DefinitionItem defitem = refitem.getDefinition();
QName qname = defitem.getQName();
if (qname != null) {
value.setFormatQName(qname);
String uri = qname.getUri();
if (uri != null) {
holder.addTypeNameReference(uri, defitem.getSchemaComponent().getSchema());
}
}
} else if (item instanceof ValueItem) {
ValueItem valitem = (ValueItem)item;
JavaType jtype = valitem.getType();
value.setFormatName(jtype.getFormat());
value.setSerializerName(jtype.getSerializerMethod());
value.setDeserializerName(jtype.getDeserializerMethod());
}
}
/**
* Generate the binding for a parent node of the data structure tree. This calls itself recursively to handle nested
* subtrees.
*
* TODO: This needs a more structured approach to creating the binding, which probably involves trying to merge the
* binding components down a particular branch of the tree as long as there's only one child (creating new
* structures as needed when the child has a name and there's already a name, or the child has a property and
* there's already a property, etc.)
*
* @param parent node to be added to binding
* @param wrapname name to be used for wrapper collection or structure, null if none
* @param wrapopt wrapper element optional flag (should be false if wrapname is null)
* @param single parent node binding component can be modified by child flag (single path from parent)
* @param bindcomp binding definition component corresponding to the parent node
* @param holder binding definition tracking information
*/
private void addToBinding(ParentNode parent, QName wrapname, boolean wrapopt, boolean single,
ContainerElementBase bindcomp, BindingHolder holder) {
// generate for each child node in turn
ArrayList children = parent.getChildren();
for (int i = 0; i < children.size(); i++) {
DataNode child = (DataNode)children.get(i);
Item item = child.getItem();
String propname = child.getPropName();
if (child.isIgnored()) {
// create structure for element to be ignored in unmarshalling
StructureElement struct = new StructureElement();
setName(child.getQName(), holder, struct);
struct.setUsage(PropertyAttributes.OPTIONAL_USAGE);
bindcomp.addChild(struct);
} else if (item.isImplicit()) {
// implicit item uses superclass data, not a field, so just handle with map-as structure
DefinitionItem def = ((ReferenceItem)item).getDefinition();
QName qname = def.getQName();
AnnotatedBase comp = def.getSchemaComponent();
int type = comp.type();
StructureElement struct = new StructureElement();
if (type == SchemaBase.ELEMENT_TYPE) {
// reference to global element definition, just set it directly as concrete mapping reference
struct.setMapAsName(getSuperClass().getBindingName());
} else {
// set reference to abstract mapping without name, since this is an implicit reference
String uri = qname.getUri();
if (uri != null) {
holder.addTypeNameReference(uri, def.getSchemaComponent().getSchema());
}
struct.setMapAsQName(qname);
}
bindcomp.addChild(struct);
} else if (child instanceof ParentNode) {
// set up for binding generation alternatives
ParentNode subparent = (ParentNode)child;
boolean empty = subparent.getChildren().size() == 0;
boolean recurse = true;
ContainerElementBase wrapcomp = bindcomp;
StructureElementBase newcomp = null;
QName newname = null;
boolean newopt = false;
if (subparent.isCollection() && !empty) {
// always create a new element for the binding to match a collection parent node
CollectionElement collect = newCollection(wrapname, wrapopt, holder, subparent);
wrapcomp.addChild(collect);
newcomp = collect;
newname = subparent.getQName();
} else {
// check for wrapper element needed (with nested name, or multiple values, or all)
boolean all = item.getSchemaComponent().type() == SchemaBase.ALL_TYPE;
boolean multi = subparent.getChildren().size() > 1;
if ((wrapname != null && (subparent.isNamed() || multi)) || (all && multi)) {
StructureElement struct = new StructureElement();
struct.setOrdered(!all);
setName(wrapname, holder, struct);
if (wrapopt) {
struct.setUsage(PropertyAttributes.OPTIONAL_USAGE);
}
wrapcomp.addChild(struct);
wrapcomp = struct;
if (!empty && bindcomp.type() == ElementBase.COLLECTION_ELEMENT &&
getSchemaCustom().getRepeatType() != SchemaRootBase.REPEAT_ARRAY) {
// dig into child node(s) to find the item type
DataNode nested = subparent;
String type = null;
while (((ParentNode)nested).getChildren().size() > 0) {
nested = (DataNode)((ParentNode)nested).getChildren().get(0);
if (nested.isCollection() || nested instanceof LeafNode) {
type = nested.getBindingType();
break;
}
}
struct.setDeclaredType(type);
}
} else {
newname = wrapname;
newopt = wrapopt;
}
// check for name associated with this node
if (subparent.isNamed()) {
// check if this is an attribute
AnnotatedBase comp = item.getSchemaComponent();
if (comp.type() == SchemaBase.ATTRIBUTE_TYPE) {
// handle attribute with embedded definition
ValueElement value = new ValueElement();
value.setEffectiveStyle(NestingAttributes.ATTRIBUTE_STYLE);
setName(subparent.getQName(), holder, value);
DataNode nested = subparent;
while ((nested = (DataNode)((ParentNode)nested).getChildren().get(0)).isInterior());
value.setGetName(((LeafNode)nested).getGetMethodName());
value.setSetName(((LeafNode)nested).getSetMethodName());
setValueHandlingOptions(item, value, holder);
wrapcomp.addChild(value);
if (SchemaUtils.isOptionalAttribute((AttributeElement)comp)) {
value.setUsage(PropertyAttributes.OPTIONAL_USAGE);
}
if (nested.isList()) {
String nestname = nested.getPropName();
value.setSerializerName(getBindingName() + '.' + LIST_SERIALIZE_PREFIX + nestname);
value.setDeserializerName(getBindingName() + '.' + LIST_DESERIALIZE_PREFIX + nestname);
} else if (getSchemaCustom().isForceTypes()) {
value.setDeclaredType(nested.getBindingType());
}
recurse = false;
} else if (subparent.getChildren().size() == 1) {
// wrapper for an embedded structure or value, just pass name
newname = subparent.getQName();
newopt = subparent.isOptional();
} else {
// create a element, using the name supplied
StructureElement struct = new StructureElement();
setName(subparent.getQName(), holder, struct);
wrapcomp.addChild(struct);
newcomp = struct;
newname = null;
newopt = false;
}
}
}
// set 'if' method and optional if inside a choice
if (parent.isSelectorNeeded()) {
if (newcomp == null) {
newcomp = new StructureElement();
setName(newname, holder, newcomp);
newname = null;
wrapcomp.addChild(newcomp);
}
newcomp.setTestName("if" + child.getSelectPropName());
newcomp.setUsage(PropertyAttributes.OPTIONAL_USAGE);
newopt = false;
}
// handle parent with no children as flag-only value
if (empty) {
// make sure there's a structure element
StructureElementBase struct = newcomp;
if (struct == null) {
// create a element, using the wrapping name supplied
if (newname == null) {
throw new IllegalStateException("Internal error - no wrapping name for empty structure");
} else {
struct = new StructureElement();
setName(newname, holder, struct);
wrapcomp.addChild(struct);
newcomp = struct;
}
}
// set flag and test methods on structure
struct.setFlagName(subparent.getFlagMethodName());
struct.setTestName(subparent.getTestMethodName());
setStructureOptional(subparent, newopt, struct);
} else {
// add choice handling for this structure
if (subparent.isSelectorNeeded()) {
if (newcomp == null) {
newcomp = new StructureElement();
setStructureOptional(subparent, false, newcomp);
wrapcomp.addChild(newcomp);
}
newcomp.setChoice(true);
newcomp.setOrdered(false);
}
// check for new binding component created for this node
if (recurse) {
if (newcomp == null) {
addToBinding(subparent, newname, newopt, single && children.size() == 1, wrapcomp, holder);
} else {
newcomp.setGetName(subparent.getGetMethodName());
newcomp.setSetName(subparent.getSetMethodName());
if (getSchemaCustom().isForceTypes()) {
newcomp.setDeclaredType(subparent.getBindingType());
}
addToBinding(subparent, newname, newopt, true, newcomp, holder);
}
}
}
} else {
LeafNode leaf = (LeafNode)child;
String gname = leaf.getGetMethodName();
String sname = leaf.getSetMethodName();
if (leaf.isAny()) {
// add structure binding with details determined by xs:any handling
int anytype = item.getComponentExtension().getAnyType();
StructureElementBase struct = (leaf.isCollection() && anytype != NestingCustomBase.ANY_DOM) ?
(StructureElementBase)new CollectionElement() : (StructureElementBase)new StructureElement();
String mapper;
switch (anytype) {
case NestingCustomBase.ANY_DISCARD:
// use discard mapper to skip past arbitrary element(s) when unmarshalling
mapper = leaf.isCollection() ? "org.jibx.extras.DiscardListMapper" :
"org.jibx.extras.DiscardElementMapper";
struct.setDeclaredType("java.lang.Object");
gname = sname = null;
break;
case NestingCustomBase.ANY_DOM:
// use DOM mapper to marshal/unmarshal arbitrary element(s)
mapper = leaf.isCollection() ? "org.jibx.extras.DomListMapper" :
"org.jibx.extras.DomElementMapper";
break;
case NestingCustomBase.ANY_MAPPED:
// create item child for case of list, otherwise just handle directly
mapper = null;
if (leaf.isCollection()) {
StructureElement itemstruct = new StructureElement();
itemstruct.setDeclaredType("java.lang.Object");
struct.addChild(itemstruct);
struct.setCreateType(m_listImplClass);
}
break;
default:
throw new IllegalStateException("Internal error - unknown xs:any handling");
}
if (leaf.isOptional()) {
struct.setUsage(PropertyAttributes.OPTIONAL_USAGE);
}
struct.setGetName(gname);
struct.setSetName(sname);
struct.setMarshallerName(mapper);
struct.setUnmarshallerName(mapper);
bindcomp.addChild(struct);
} else {
// set the names to be used for value
if (leaf.isCollection() || leaf.isList()) {
// process list and collection differently for binding
if (leaf.isCollection()) {
// create a new collection element
CollectionElement collect = newCollection(wrapname, wrapopt, holder, leaf);
bindcomp.addChild(collect);
// fill in the collection details
collect.setGetName(gname);
collect.setSetName(sname);
if (parent.isSelectorNeeded()) {
collect.setUsage(PropertyAttributes.OPTIONAL_USAGE);
collect.setTestName("if" + leaf.getSelectPropName());
}
int reptype = getSchemaCustom().getRepeatType();
if (reptype == SchemaRootBase.REPEAT_LIST || reptype == SchemaRootBase.REPEAT_TYPED) {
collect.setCreateType(m_listImplClass);
if (gname == null) {
collect.setDeclaredType(COLLECTION_VARIABLE_TYPE);
}
}
// check the content (if any) for
boolean usevalue = true;
String usetype = leaf.getType();
if (item instanceof ReferenceItem) {
DefinitionItem def = ((ReferenceItem)item).getDefinition();
TypeData defclas = def.getGenerateClass();
if (defclas.isSimpleValue()) {
usetype = defclas.getBindingName();
} else {
// reference to mapped class, configure to handle it properly
usevalue = false;
if (def.getSchemaComponent().type() == SchemaBase.ELEMENT_TYPE) {
// must be a non-abstract , so use it directly
collect.setItemTypeName(defclas.getBindingName());
} else {
// abstract mapping reference, create child with map-as type
StructureElement struct = new StructureElement();
QName qname = def.getQName();
String uri = qname.getUri();
if (uri != null) {
holder.addTypeNameReference(uri, def.getSchemaComponent().getSchema());
}
struct.setMapAsQName(qname);
if (leaf.isNamed()) {
setName(leaf.getQName(), holder, struct);
}
collect.addChild(struct);
}
}
} else if (item instanceof GroupItem) {
// handle group directly if a structure class, else just as
TypeData groupclas = ((GroupItem)item).getGenerateClass();
if (groupclas.isSimpleValue()) {
usetype = groupclas.getBindingName();
} else {
// add element to be filled in by inner class generation
usevalue = false;
StructureClassHolder classholder = ((StructureClassHolder)groupclas);
StructureElement struct = new StructureElement();
struct.setDeclaredType(classholder.getBindingName());
setName(leaf.getQName(), holder, struct);
// set component for dependent class generation
classholder.setBinding(struct);
collect.addChild(struct);
}
}
if (usevalue) {
// add element to collection for simple (primitive or text) value
ValueElement value = new ValueElement();
value.setEffectiveStyle(NestingAttributes.ELEMENT_STYLE);
if (leaf.isNamed()) {
setName(leaf.getQName(), holder, value);
}
setValueHandlingOptions(item, value, holder);
value.setDeclaredType(usetype);
collect.addChild(value);
}
} else {
// handle list serialization and deserialization directly
ValueElement value = buildValueBinding(leaf, null, gname, sname, holder);
value.setSerializerName(getBindingName() + '.' + LIST_SERIALIZE_PREFIX + propname);
value.setDeserializerName(getBindingName() + '.' + LIST_DESERIALIZE_PREFIX + propname);
bindcomp.addChild(value);
}
} else {
// add wrapper if name passed in with name on value
ContainerElementBase contain = bindcomp;
boolean consing = single && children.size() == 1;
if (wrapname != null && (leaf.isNamed() || leaf.isReference())) {
StructureElement struct = new StructureElement();
setName(wrapname, holder, struct);
String type = leaf.getBindingType();
if (gname == null) {
struct.setDeclaredType(type);
} else if (!Types.isSimpleValue(type)) {
// apply access methods to wrapper only if this is a complex value
struct.setGetName(gname);
struct.setSetName(sname);
gname = sname = null;
if (getSchemaCustom().isForceTypes()) {
struct.setDeclaredType(type);
}
}
if (wrapopt) {
struct.setUsage(PropertyAttributes.OPTIONAL_USAGE);
}
contain.addChild(struct);
contain = struct;
consing = true;
wrapname = null;
wrapopt = false;
}
// build the appropriate binding representation
StructureElement struct = null;
if (item instanceof ReferenceItem) {
// handle reference directly if a structure class, else just as value
DefinitionItem def = ((ReferenceItem)item).getDefinition();
TypeData defclas = def.getGenerateClass();
if (!defclas.isSimpleValue()) {
struct = addReferenceStructure(leaf, def, consing, holder, contain);
}
} else if (item instanceof GroupItem) {
// handle group directly if a structure class, else just as value
TypeData groupclas = ((GroupItem)item).getGenerateClass();
if (!groupclas.isSimpleValue()) {
// create a new element for reference
struct = new StructureElement();
StructureClassHolder refclas = (StructureClassHolder)groupclas;
if (gname == null) {
struct.setDeclaredType(refclas.getBindingName());
}
// set the binding component to be filled in by inner class generation
refclas.setBinding(struct);
}
}
if (struct == null) {
// add simple binding for field
ValueElement value = buildValueBinding(leaf, wrapname, gname, sname, holder);
if (getSchemaCustom().isForceTypes()) {
value.setDeclaredType(leaf.getBindingType());
}
if (wrapopt) {
value.setUsage(PropertyAttributes.OPTIONAL_USAGE);
}
contain.addChild(value);
} else {
// fill in structure attributes
struct.setGetName(gname);
struct.setSetName(sname);
if (getSchemaCustom().isForceTypes()) {
struct.setDeclaredType(leaf.getBindingType());
}
// set the name and optional status from wrapper or item
setName(wrapname == null ? leaf.getQName() : wrapname, holder, struct);
setStructureOptional(leaf, wrapopt, struct);
// common handling for structure
if (parent.isSelectorNeeded()) {
struct.setUsage(PropertyAttributes.OPTIONAL_USAGE);
struct.setTestName("if" + leaf.getSelectPropName());
}
// add to containing binding component
if (struct != contain) {
contain.addChild(struct);
}
}
}
}
}
}
}
/**
* Generate this class.
*
* @param verbose
* @param builder class source file builder
*/
public void generate(boolean verbose, SourceBuilder builder) {
// setup the class builder
String name = getName();
ClassBuilder clasbuilder;
if (m_outerClass == null) {
clasbuilder = builder.newMainClass(name, false);
} else {
clasbuilder = builder.newInnerClass(name, m_outerClass.getBuilder(), false);
}
// handle the common initialization
initClass(verbose, clasbuilder, m_dataRoot);
// add nested definitions to
if (m_bindingElement instanceof MappingElement) {
addInnerFormats((MappingElementBase)m_bindingElement);
}
// add choice handling if needed
if (m_dataRoot.isSelectorNeeded()) {
m_bindingElement.setChoice(true);
m_bindingElement.setOrdered(false);
}
// fix all the value names
String fullname = getFullName();
if (s_logger.isInfoEnabled()) {
s_logger.info("Generating class " + fullname + ":\n" + m_dataRoot.describe(0));
}
addFixedNames(m_dataRoot);
fixFlexibleNames(m_dataRoot, false);
// make class abstract if appropriate
AnnotatedBase comp = m_dataRoot.getSchemaComponent();
boolean abs = false;
int type = comp.type();
if (type == SchemaBase.ELEMENT_TYPE) {
abs = ((ElementElement)comp).isAbstract();
} else if (type == SchemaBase.COMPLEXTYPE_TYPE) {
abs = ((ComplexTypeElement)comp).isAbstract();
}
if (abs) {
getBuilder().setAbstract();
}
// generate the class data structure
addToClass(m_dataRoot);
if (s_logger.isInfoEnabled()) {
s_logger.info("Class " + fullname + " after fields generated:\n" + m_dataRoot.describe(0));
}
addToBinding(m_dataRoot, null, false, false, m_bindingElement, m_holder);
// generate the binding code
// m_classBuilder.addInterface("org.jibx.v2.MappedStructure");
// finish with subclass generation
generateInner(verbose, builder);
finishClass(m_bindingElement);
// check for empty elements to be deleted from
if (m_bindingElement instanceof MappingElement) {
MappingElementBase mapping = (MappingElementBase)m_bindingElement;
ArrayList childs = mapping.topChildren();
int fill = 0;
for (int i = 0; i < childs.size(); i++) {
Object child = childs.get(i);
boolean keep = true;
if (child instanceof FormatElement) {
FormatElement format = (FormatElement)child;
keep = format.getDefaultText() != null || format.getDeserializerName() != null ||
format.getEnumValueName() != null || format.getSerializerName() != null;
}
if (keep) {
childs.set(fill++, child);
}
}
while (fill < childs.size()) {
childs.remove(childs.size()-1);
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/InvocationBuilder.java 0000644 0001750 0001750 00000004601 10713703146 027001 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.MethodInvocation;
/**
* Method invocation builder. This wraps the AST method invocation representation with convenience methods and added
* control information.
*/
public class InvocationBuilder extends ExpressionBuilderBase
{
/** Method invocation. */
private final MethodInvocation m_invoke;
/**
* Constructor.
*
* @param source
* @param invoke
*/
public InvocationBuilder(ClassBuilder source, MethodInvocation invoke) {
super(source, invoke);
m_invoke = invoke;
}
/**
* Add operand to expression. This just adds the supplied operand expression as a new method parameter.
*
* @param operand
*/
protected void addOperand(Expression operand) {
m_invoke.arguments().add(operand);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/DataModelUtils.java 0000644 0001750 0001750 00000022372 11365045062 026241 0 ustar twerner twerner /*
* Copyright (c) 2008-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.util.ArrayList;
/**
* Utility methods for working with generated data models.
*/
public class DataModelUtils
{
/**
* Get the complete data model.
*
* @param directory
* @return ordered list of class name-values array pairs
*/
public static StringObjectPair[] getImage(PackageOrganizer directory) {
ArrayList packs = directory.getPackages();
ArrayList classdetails = new ArrayList();
for (int i = 0; i < packs.size(); i++) {
StringObjectPair[] classfields = ((PackageHolder)packs.get(i)).getClassFields();
for (int j = 0; j < classfields.length; j++) {
classdetails.add(classfields[j]);
}
}
return (StringObjectPair[])classdetails.toArray(new StringObjectPair[classdetails.size()]);
}
/**
* Write a complete generated data model.
*
* @param directory
* @param writer
* @throws IOException
*/
public static void writeImage(PackageOrganizer directory, BufferedWriter writer) throws IOException {
ArrayList packs = directory.getPackages();
for (int i = 0; i < packs.size(); i++) {
StringObjectPair[] claspairs = ((PackageHolder)packs.get(i)).getClassFields();
for (int j = 0; j < claspairs.length; j++) {
StringObjectPair claspair = claspairs[j];
writer.write(claspair.getKey());
writer.newLine();
StringPair[] fields = (StringPair[])claspair.getValue();
for (int k = 0; k < fields.length; k++) {
StringPair field = fields[k];
writer.write(' ');
writer.write(field.getKey());
writer.write(" (");
writer.write(field.getValue());
writer.write(')');
writer.newLine();
}
}
}
}
/**
* Read a complete generated data model.
*
* @param reader
* @return ordered list of class name-values array pairs
* @throws IOException
*/
public static StringObjectPair[] readImage(BufferedReader reader) throws IOException {
String line;
ArrayList clasdetails = new ArrayList();
ArrayList values = new ArrayList();
String clasname = null;
while ((line = reader.readLine()) != null) {
if (line.charAt(0) == ' ') {
int split = line.indexOf(' ', 1);
String name = line.substring(1, split);
split = line.indexOf('(', split);
String type = line.substring(split+1, line.length()-1);
values.add(new StringPair(name, type));
} else {
if (clasname != null) {
StringPair[] valuepairs = (StringPair[])values.toArray(new StringPair[values.size()]);
clasdetails.add(new StringObjectPair(clasname, valuepairs));
}
values.clear();
clasname = line;
}
}
return (StringObjectPair[])clasdetails.toArray(new StringObjectPair[clasdetails.size()]);
}
/**
* List the values in a class.
*
* @param values
* @param buff
*/
private static void listClass(StringPair[] values, StringBuffer buff) {
for (int i = 0; i < values.length; i++) {
buff.append(' ');
buff.append(values[i].getKey());
buff.append(" of type ");
buff.append(values[i].getValue());
buff.append('\n');
}
}
/**
* Find the difference between two class value lists.
*
* @param name
* @param pairs1
* @param pairs2
* @param buff
*/
private static void classDiff(String name, StringPair[] pairs1, StringPair[] pairs2, StringBuffer buff) {
int index1 = 0;
int index2 = 0;
boolean header = true;
while (true) {
StringPair pair1 = null;
StringPair pair2 = null;
boolean delta = false;
int diff = -1;
if (index1 < pairs1.length) {
pair1 = pairs1[index1];
}
if (index2 < pairs2.length) {
pair2 = pairs2[index2];
if (pair1 == null) {
diff = 1;
} else {
diff = pair1.getKey().compareTo(pair2.getKey());
if (diff == 0) {
delta = !pair1.getValue().equals(pair2.getValue());
}
}
} else if (pair1 == null) {
break;
}
if (delta || diff != 0) {
if (header) {
buff.append("Difference(s) for class ");
buff.append(name);
buff.append(":\n");
header = false;
}
if (diff < 0) {
buff.append(" Missing value '");
buff.append(pair1.getKey());
buff.append("' of type ");
buff.append(pair1.getValue());
index1++;
} else if (diff > 0) {
buff.append(" Added value '");
buff.append(pair2.getKey());
buff.append("' of type ");
buff.append(pair2.getValue());
index2++;
} else {
buff.append(" Value '");
buff.append(pair1.getKey());
buff.append("' type was ");
buff.append(pair1.getValue());
buff.append(", changed to ");
buff.append(pair2.getValue());
}
buff.append('\n');
}
if (diff == 0) {
index1++;
index2++;
}
}
}
/**
* Find the difference between two data model images.
*
* @param pairs1 reference data model, as class name-value array pairs
* @param pairs2 comparison data model, as class name-value array pairs
* @return comparison text output
*/
public static String imageDiff(StringObjectPair[] pairs1, StringObjectPair[] pairs2) {
StringBuffer buff = new StringBuffer();
int index1 = 0;
int index2 = 0;
while (true) {
StringObjectPair pair1 = null;
StringObjectPair pair2 = null;
int diff = -1;
if (index1 < pairs1.length) {
pair1 = pairs1[index1];
}
if (index2 < pairs2.length) {
pair2 = pairs2[index2];
if (pair1 == null) {
diff = 1;
} else {
diff = pair1.getKey().compareTo(pair2.getKey());
}
} else if (pair1 == null) {
break;
}
if (diff == 0) {
classDiff(pair1.getKey(), (StringPair[])pair1.getValue(), (StringPair[])pair2.getValue(), buff);
index1++;
index2++;
} else if (diff < 0) {
buff.append("Second image is missing class " + pair1.getKey() + ":\n");
listClass((StringPair[])pair1.getValue(), buff);
index1++;
} else {
buff.append("Second image has added class " + pair2.getKey() + ":\n");
listClass((StringPair[])pair2.getValue(), buff);
index2++;
}
}
if (buff.length() == 0) {
return null;
} else {
return buff.toString();
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/BodyBuilderBase.java 0000644 0001750 0001750 00000011374 11130765752 026372 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.BodyDeclaration;
import org.eclipse.jdt.core.dom.Javadoc;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.TagElement;
import org.eclipse.jdt.core.dom.TextElement;
/**
* Abstract syntax tree body declaration builder base. This adds convenience methods and control information to the base
* builder.
*/
public class BodyBuilderBase extends ASTBuilderBase
{
/** Source builder. */
protected final ClassBuilder m_source;
/** Body declaration under construction. */
protected final BodyDeclaration m_declaration;
/**
* Constructor.
*
* @param source
* @param decl
*/
public BodyBuilderBase(ClassBuilder source, BodyDeclaration decl) {
super(source.getAST());
m_source = source;
m_declaration = decl;
}
/**
* Set the public access flag.
*/
public void setPublic() {
m_declaration.modifiers().add(m_ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));
}
/**
* Set the private access flag.
*/
public void setPrivate() {
m_declaration.modifiers().add(m_ast.newModifier(Modifier.ModifierKeyword.PRIVATE_KEYWORD));
}
/**
* Set the static flag.
*/
public void setStatic() {
m_declaration.modifiers().add(m_ast.newModifier(Modifier.ModifierKeyword.STATIC_KEYWORD));
}
/**
* Set the final flag.
*/
public void setFinal() {
m_declaration.modifiers().add(m_ast.newModifier(Modifier.ModifierKeyword.FINAL_KEYWORD));
}
/**
* Set private final flags.
*/
public void setPrivateFinal() {
setPrivate();
setFinal();
}
/**
* Set private static final flags.
*/
public void setPrivateStaticFinal() {
setPrivate();
setStatic();
setFinal();
}
/**
* Set public static flags.
*/
public void setPublicStatic() {
setPublic();
setStatic();
}
/**
* Set public static final flags.
*/
public void setPublicStaticFinal() {
setPublic();
setStatic();
setFinal();
}
/**
* Add optionally tagged source comment for this body.
*
* @param name tag name (add comment without tag if null)
* @param text comment text, null value ignored
*/
public void addSourceComment(String name, String text) {
if (text != null) {
AST ast = m_source.getAST();
TextElement element = ast.newTextElement();
element.setText(text);
TagElement tag = ast.newTagElement();
tag.setTagName(name);
tag.fragments().add(element);
Javadoc javadoc = m_declaration.getJavadoc();
if (javadoc == null) {
javadoc = ast.newJavadoc();
m_declaration.setJavadoc(javadoc);
}
javadoc.tags().add(tag);
}
}
/**
* Add untagged source comment for this body.
*
* @param text comment text, null value ignored
*/
public void addSourceComment(String text) {
addSourceComment(null, text);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/custom/ 0000755 0001750 0001750 00000000000 11526304016 024023 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/custom/SchemaExtension.java 0000644 0001750 0001750 00000015057 11424512576 030004 0 ustar twerner twerner /*
* Copyright (c) 2008-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.custom;
import java.util.Map;
import org.jibx.schema.codegen.PackageHolder;
import org.jibx.schema.codegen.extend.ClassDecorator;
import org.jibx.schema.codegen.extend.NameConverter;
import org.jibx.schema.elements.SchemaElement;
/**
* Extension information for a schema element.
*
* @author Dennis M. Sosnoski
*/
public class SchemaExtension extends BaseExtension
{
/** Customization information for the schema. */
private final SchemaCustom m_custom;
/** Map from schema type name to Java type information. */
private Map m_schemaTypes;
/** Name converter instance (null if none set at level). */
private NameConverter m_nameConverter;
/** Decorators to be used in code generation (null if none set at level). */
private ClassDecorator[] m_decorators;
/** Package to be used for class generation (may be null if no code generation). */
private final PackageHolder m_package;
/** Force a binding for this schema flag. */
private final boolean m_forceBinding;
/** Binding file name (only allowed if single namespace, null if derived from schema name). */
private final String m_bindingFileName;
/** Prefix used for namespace (only allowed if single namespace, null if from schema). */
private final String m_prefix;
/** Inline xs:group and xs:attributeGroup definitions by default. */
private final boolean m_inlineGroups;
/** Prefer inline definitions. */
private final boolean m_preferInline;
/** Use inner classes for substructures. */
private final boolean m_useInnerClasses;
/** Always specify property types flag. */
private boolean m_forceTypes;
/**
* Constructor.
*
* @param schema root element of schema definition
* @param custom schema customizations
* @param pack package for code generated from schema
*/
public SchemaExtension(SchemaElement schema, SchemaCustom custom, PackageHolder pack) {
super(schema);
m_schemaTypes = custom.getSchemaTypes();
m_nameConverter = custom.getNameConverter();
m_decorators = custom.getClassDecorators();
m_package = pack;
m_bindingFileName = custom.getBindingFileName();
m_forceBinding = custom.isBindingPerSchema();
m_prefix = custom.getPrefix();
m_inlineGroups = custom.isInlineGroups();
m_preferInline = custom.isPreferInline();
m_useInnerClasses = custom.isUseInner();
setTypeReplacer(custom);
m_custom = custom;
}
/**
* Get the containing global extension.
*
* @return global
*/
public SchemaCustom getCustom() {
return m_custom;
}
/**
* Get map from schema type local name to type information.
*
* @return map
*/
public Map getSchemaTypes() {
return m_schemaTypes;
}
/**
* Get name converter used for this component.
*
* @return converter
*/
public NameConverter getNameConverter() {
return m_nameConverter;
}
/**
* Get code generation decorators used for this component.
*
* @return converter
*/
public ClassDecorator[] getClassDecorators() {
return m_decorators;
}
/**
* Get package for class generation.
*
* @return package
*/
public PackageHolder getPackage() {
return m_package;
}
/**
* Check if separate binding forced for schema.
*
* @return forced
*/
public boolean isForceBinding() {
return m_forceBinding;
}
/**
* Get binding definition file name. The binding name may not be set if more than one namespace is used in the
* schemas represented by this customization.
*
* @return name, null if to be derived from schema name
*/
public String getBindingFileName() {
return m_bindingFileName;
}
/**
* Get prefix used for namespace. The prefix may not be set if more than one namespace is used in the schemas
* represented by this customization.
*
* @return prefix, null if to be found from schema
*/
public String getPrefix() {
return m_prefix;
}
/**
* Check whether xs:group and xs:attributeGroup definitions should be inlined by default.
*
* @return generate unused flag
*/
public boolean isInlineGroups() {
return m_inlineGroups;
}
/**
* Check if inlining of definition preferred.
*
* @return inline
*/
public boolean isPreferInline() {
return m_preferInline;
}
/**
* Check if inner classes should be used for substructures.
*
* @return inner
*/
public boolean isUseInnerClasses() {
return m_useInnerClasses;
}
/**
* Check if type specifications forced for schema.
*
* @return force
*/
public boolean isForceTypes() {
return m_forceTypes;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/custom/GlobalExtension.java 0000644 0001750 0001750 00000023161 11300601432 027756 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.custom;
import java.util.ArrayList;
import java.util.Map;
import org.apache.log4j.Logger;
import org.jibx.schema.INamed;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.codegen.DefinitionItem;
import org.jibx.schema.codegen.PackageHolder;
import org.jibx.schema.codegen.extend.ClassDecorator;
import org.jibx.schema.codegen.extend.NameConverter;
import org.jibx.schema.elements.OpenAttrBase;
import org.jibx.schema.elements.SchemaBase;
import org.jibx.schema.elements.SchemaElement;
/**
* Extension information for a schema global definition component. This adds reference tracking to the basic extension
* information, along with a map for child components of the definition.
*
* @author Dennis M. Sosnoski
*/
public class GlobalExtension extends ComponentExtension
{
/** Logger for class. */
static final Logger s_logger = Logger.getLogger(GlobalExtension.class.getName());
/** Containing schema extension. */
private final SchemaExtension m_schemaExtension;
/** Component to be specifically included in code generation (requiring a separate class). */
private boolean m_included;
/** Number of references to this definition. */
private int m_referenceCount;
/** List of extensions for components referencing this definition. */
private ArrayList m_references;
/** List of global definitions used by this definition (one entry per reference, may contain duplicates). */
private ArrayList m_dependencies;
/** Definition item for this global definition. */
private DefinitionItem m_definition;
/**
* Constructor.
*
* @param schemext extension for containing schema
* @param comp actual component
*/
public GlobalExtension(SchemaExtension schemext, OpenAttrBase comp) {
super(comp, null);
m_schemaExtension = schemext;
}
//
// Methods delegated to schema extension
/**
* Get map from schema type local name to type information.
*
* @return map
*/
public Map getSchemaTypes() {
return m_schemaExtension.getSchemaTypes();
}
/**
* Get name converter used for this component.
*
* @return converter
*/
public NameConverter getNameConverter() {
return m_schemaExtension.getNameConverter();
}
/**
* Get code generation decorators used for this component.
*
* @return converter
*/
public ClassDecorator[] getClassDecorators() {
return m_schemaExtension.getClassDecorators();
}
/**
* Get package for class generation.
*
* @return package
*/
public PackageHolder getPackage() {
return m_schemaExtension.getPackage();
}
/**
* Check if inlining of definition is pushed (even when multiple values are involved).
*
* @return inline
*/
public boolean isPushInline() {
int type = getComponent().type();
if (type == SchemaBase.ATTRIBUTEGROUP_TYPE || type == SchemaBase.GROUP_TYPE) {
return m_schemaExtension.isInlineGroups();
} else {
return false;
}
}
/**
* Check if inlining of definition preferred. Inlining of xs:attributeGroup and xs:group definitions is always
* preferred.
*
* @return inline
*/
public boolean isPreferInline() {
return m_schemaExtension.isPreferInline();
}
/**
* Check if inner classes should be used for substructures.
*
* @return inner
*/
public boolean isUseInnerClasses() {
return m_schemaExtension.isUseInnerClasses();
}
//
// Instance methods
/**
* Check if component specifically included in code generation (requiring a separate class).
*
* @return included
*/
public boolean isIncluded() {
return m_included;
}
/**
* Set flag for component specifically included in code generation (requiring a separate class).
*
* @param included
*/
public void setIncluded(boolean included) {
m_included = included;
}
/**
* Add reference extension.
*
* @param anno
*/
public void addReference(ComponentExtension anno) {
if (m_references == null) {
m_references = new ArrayList();
}
m_references.add(anno);
m_referenceCount++;
}
/**
* Get referencing extension by index position.
*
* @param index
* @return reference
*/
public ComponentExtension getReference(int index) {
return (ComponentExtension)m_references.get(index);
}
/**
* Add dependency extension.
*
* @param anno
*/
public void addDependency(ComponentExtension anno) {
if (m_dependencies == null) {
m_dependencies = new ArrayList();
}
m_dependencies.add(anno);
}
/**
* Get the number of dependencies for this component.
*
* @return count
*/
public int getDependencyCount() {
if (m_dependencies == null) {
return 0;
} else {
return m_dependencies.size();
}
}
/**
* Get dependency extension by index position.
*
* @param index
* @return reference
*/
public GlobalExtension getDependency(int index) {
return (GlobalExtension)m_dependencies.get(index);
}
/**
* Reset the dependencies and references of this component. This must be called before beginning a reference
* tracking pass, to clear any information from prior passes.
*/
public void resetDependencies() {
if (m_dependencies != null) {
m_dependencies.clear();
}
if (m_references != null) {
m_references.clear();
}
m_referenceCount = 0;
}
/**
* Check if the global definition can be removed from the schema. If it can, this adjusts the usage counts for all
* dependencies of the definition, forcing a check of each dependency as the counts are adjusted.
*/
public void checkRemovable() {
if (!isRemoved()) {
if (m_referenceCount > 0) {
if (s_logger.isDebugEnabled()) {
OpenAttrBase component = getComponent();
s_logger.debug("Retaining " + ((INamed)component).getQName() + " from schema " +
((SchemaElement)component.getParent()).getResolver().getName() + " with " + m_referenceCount +
" references");
}
} else if (!m_included && !isRemoved() && m_referenceCount == 0) {
// flag definition for deletion
setRemoved(true);
if (s_logger.isDebugEnabled()) {
OpenAttrBase component = getComponent();
s_logger.debug(" Flagging deletion of " + ((INamed)component).getQName() + " from schema " +
((SchemaElement)component.getParent()).getResolver().getName());
}
// recursively adjust the usage counts for dependencies
for (int j = 0; j < getDependencyCount(); j++) {
GlobalExtension dependency = getDependency(j);
dependency.m_referenceCount--;
dependency.checkRemovable();
}
}
}
}
/**
* Get definition item.
*
* @return item
*/
public DefinitionItem getDefinition() {
return m_definition;
}
/**
* Set definition item.
*
* @param item
*/
public void setDefinition(DefinitionItem item) {
m_definition = item;
}
/**
* Normalize the schema definition component. This recursively traverses the schema model tree rooted in the
* global component, normalizing each child component.
*/
public void normalize() {
if (s_logger.isDebugEnabled()) {
s_logger.debug("Normalization invoked for global " + SchemaUtils.componentPath(getComponent()));
}
while (getOverrideType() == null && normalize(0));
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/custom/ComponentCustom.java 0000644 0001750 0001750 00000020312 11261472452 030027 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.custom;
import java.util.Iterator;
import java.util.List;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.QName;
import org.jibx.schema.elements.OpenAttrBase;
import org.jibx.schema.elements.SchemaPath;
import org.jibx.schema.support.Conversions;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.LazyList;
/**
* Class for all schema component elements, with the exception of the <schema> element itself. Almost all of these
* schema elements can contain other elements, so this extends the nesting base to handle inherited values.
*
* @author Dennis M. Sosnoski
*/
public class ComponentCustom extends NestingCustomBase
{
//
// Value set information
public static final int INLINE_DEFAULT = 0;
public static final int INLINE_BLOCK = 1;
public static final int INLINE_PREFER = 2;
public static final EnumSet s_inlineValues = new EnumSet(INLINE_DEFAULT,
new String[] { "default", "block", "prefer"});
//
// Fixed fields.
/** Schema element name. */
private final String m_elementName;
//
// Bound fields.
/** Path to component (null if not specified). */
private String m_path;
/** Component position in siblings of same type (null if not specified). */
private String m_position;
/** Component name, if relevant. */
private String m_componentName;
/** Ignore component flag. */
private boolean m_ignore;
/** Exclude component flag. */
private boolean m_exclude;
/** Code for inlining. */
private int m_inline = INLINE_DEFAULT;
/** Corresponding generated class name (null if not specified). */
private String m_className;
/** Base name for corresponding property in generated code (null if not specified). */
private String m_baseName;
/** Actual type to be used. */
private QName m_type;
/**
* Constructor.
*
* @param name schema element name
* @param parent
*/
public ComponentCustom(String name, NestingCustomBase parent) {
super(parent);
m_elementName = name;
}
/**
* Get the schema element name for the component.
*
* @return name
*/
public final String getElementName() {
return m_elementName;
}
/**
* Build the schema path for this customization.
*
* @param vctx validation context
* @return path constructed path, or null if error
*/
public final SchemaPath buildPath(ValidationContext vctx) {
return SchemaPath.buildPath(m_path, getElementName(), m_componentName, m_position, this, vctx);
}
/**
* Check if schema component is to be ignored (allowed, but not processed, in unmarshalling). This is only
* applicable to element definitions.
*
* @return true if ignored, false if not
*/
public boolean isIgnored() {
return m_ignore;
}
/**
* Check if schema component is to be excluded.
*
* @return true if ignored, false if not
*/
public boolean isExcluded() {
return m_exclude;
}
/**
* Check if schema component is to be generated inline.
*
* @return true if inlined, false if not
*/
public boolean isInlined() {
return m_inline == INLINE_PREFER;
}
/**
* Check if schema component is to be generated as a separate class.
*
* @return true if separate class, false if not
*/
public boolean isSeparateClass() {
return m_inline == INLINE_BLOCK;
}
/**
* Get name to be used for generated class.
*
* @return class name (null if not set)
*/
public String getClassName() {
return m_className;
}
/**
* Get base name for corresponding property.
*
* @return property name (null if not set)
*/
public String getBaseName() {
return m_baseName;
}
/**
* Set the inline text value. This method is provided only for use when unmarshalling.
*
* @param text (null if not set)
* @param ictx
*/
private void setInline(String text, IUnmarshallingContext ictx) {
if (text != null) {
m_inline = Conversions.convertEnumeration(text, s_inlineValues, "inline", ictx);
}
}
/**
* Apply customizations to a schema extension. This also finds matches for any child customizations, and applies
* the child customizations recursively. The method may be called multiple times for different component extensions,
* so it must not modify the customization information itself.
*
* @param exten target schema extension
* @param vctx validation context
*/
public final void apply(ComponentExtension exten, ValidationContext vctx) {
if (validate(vctx)) {
exten.setCustom(this);
if (isExcluded()) {
// flag component removed from schema
exten.setRemoved(true);
// warn that any child customizations are ignored
if (getChildren().size() > 0) {
vctx.addWarning("Child customizations ignored for skipped component", this);
}
} else {
// apply customizations to extension
exten.setTypeReplacer(this);
exten.setOverrideType(m_type);
// match and apply child customizations
LazyList childs = getChildren();
for (int i = 0; i < childs.size(); i++) {
ComponentCustom child = (ComponentCustom)childs.get(i);
SchemaPath path = child.buildPath(vctx);
if (path != null) {
List matches = path.partialMatchMultiple(0, path.getPathLength()-1, exten.getComponent());
if (matches.size() == 0) {
vctx.addWarning("No matches found for customization expression", child);
} else {
for (Iterator iter = matches.iterator(); iter.hasNext();) {
OpenAttrBase target = (OpenAttrBase)iter.next();
child.apply((ComponentExtension)target.getExtension(), vctx);
}
}
}
}
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/custom/ComponentCustomUnmarshaller.java 0000644 0001750 0001750 00000020566 11332650376 032422 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.custom;
import java.util.Arrays;
import org.jibx.runtime.IUnmarshaller;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.schema.elements.FacetElement;
import org.jibx.schema.elements.SchemaBase;
import org.jibx.schema.validation.ProblemLocation;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Unmarshaller class for all nested customizations. This is used for all the customizations below the <schema>
* level.
*/
public class ComponentCustomUnmarshaller implements IUnmarshaller
{
/** Attribute names allowed for all types of components. */
public static final StringArray s_baseAttributes =
new StringArray(new String[] { "inline", "path", "position" }, NestingCustomBase.s_allowedAttributes);
/** Attribute names allowed for all excludable components. */
public static final StringArray s_ignorableAttributes =
new StringArray(new String[] { "exclude" }, s_baseAttributes);
/** Mask for elements with values but no names. */
private static final long s_unnamedValueMask;
/** Allowed attribute names for customizing elements with values but no names. */
public static final StringArray s_unnamedValueAttributes =
new StringArray(new String[] { "class-name", "type", "value-name" }, s_ignorableAttributes);
/** Mask for elements with values and names. */
private static final long s_namedValueMask;
/** Allowed attribute names for customizing elements with values and names. */
public static final StringArray s_namedValueAttributes =
new StringArray(new String[] { "name" }, s_unnamedValueAttributes);
/** Mask for elements with names which can be ignored. */
private static final long s_namedIgnorableValueMask;
/** Allowed attribute names for customizing elements with values and names. */
public static final StringArray s_namedIgnorableValueAttributes =
new StringArray(new String[] { "ignore" }, s_namedValueAttributes);
/** Mask for type definition elements. */
private static final long s_typeDefinitionMask;
/** Allowed attribute names for type definition elements. */
public static final StringArray s_typeDefinitionAttributes =
new StringArray(new String[] { "class-name", "name" }, s_ignorableAttributes);
/** Mask for elements which are not deletable but do support nesting. */
private static final long s_simpleNestingMask;
/** Mask for elements which are deletable but do not support nesting. */
private static final long s_deletableLeafMask;
static {
long[] masks = SchemaBase.ELEMENT_MASKS;
long mask = masks[SchemaBase.ATTRIBUTE_TYPE];
mask |= masks[SchemaBase.ELEMENT_TYPE];
s_namedIgnorableValueMask = mask;
mask |= masks[SchemaBase.ATTRIBUTEGROUP_TYPE];
mask |= masks[SchemaBase.GROUP_TYPE];
s_namedValueMask = mask;
mask = masks[SchemaBase.ALL_TYPE];
mask |= masks[SchemaBase.CHOICE_TYPE];
mask |= masks[SchemaBase.SEQUENCE_TYPE];
s_unnamedValueMask = mask;
mask = masks[SchemaBase.COMPLEXTYPE_TYPE];
mask |= masks[SchemaBase.SIMPLETYPE_TYPE];
s_typeDefinitionMask = mask;
mask = SchemaBase.COMPLEXCONTENT_TYPE;
mask |= masks[SchemaBase.EXTENSION_TYPE];
mask |= masks[SchemaBase.LIST_TYPE];
mask |= masks[SchemaBase.RESTRICTION_TYPE];
mask |= masks[SchemaBase.SIMPLECONTENT_TYPE];
mask |= masks[SchemaBase.UNION_TYPE];
s_simpleNestingMask = mask;
mask = FacetElement.FACET_ELEMENT_MASK;
mask |= masks[SchemaBase.ANY_TYPE];
mask |= masks[SchemaBase.ANYATTRIBUTE_TYPE];
s_deletableLeafMask = mask;
};
/**
* Check if element present. If there's a start tag, we want to handle it.
*
* @param ctx
* @return true if at a start tag
* @throws JiBXException
*/
public boolean isPresent(IUnmarshallingContext ctx) throws JiBXException {
return ctx.isStart();
}
/**
* Unmarshal the element. This matches the current start tag name to the corresponding schema component element,
* then unmarshals the content based on the type of schema element (invoking the abstract unmarshaller defined
* in the binding for the actual content).
*
* @param obj ignored
* @param ictx unmarshalling context
* @return unmarshalled instance
* @throws JiBXException on error in document
*/
public Object unmarshal(Object obj, IUnmarshallingContext ictx) throws JiBXException {
// make sure current element name matches an allowed schema element
UnmarshallingContext ctx = (UnmarshallingContext)ictx;
String name = ctx.getElementName();
int index = Arrays.binarySearch(SchemaBase.ELEMENT_NAMES, name);
if (index >= 0) {
// check the type of element
long mask = SchemaBase.ELEMENT_MASKS[index];
StringArray attrs = null;
if ((mask & s_namedIgnorableValueMask) != 0) {
attrs = s_namedIgnorableValueAttributes;
} else if ((mask & s_namedValueMask) != 0) {
attrs = s_namedValueAttributes;
} else if ((mask & s_unnamedValueMask) != 0) {
attrs = s_unnamedValueAttributes;
} else if ((mask & s_typeDefinitionMask) != 0) {
attrs = s_typeDefinitionAttributes;
} else if ((mask & s_simpleNestingMask) != 0) {
attrs = s_baseAttributes;
} else if ((mask & s_deletableLeafMask) != 0) {
attrs = s_ignorableAttributes;
}
if (attrs != null) {
// create an instance and unmarshal with the appropriate handling
ComponentCustom comp = new ComponentCustom(name,
(NestingCustomBase)CustomBase.getContainingObject(ictx));
comp.validateAttributes(ictx, attrs);
ctx.getUnmarshaller("component-custom").unmarshal(comp, ctx);
ctx.parsePastCurrentEndTag(null, name);
return comp;
} else {
// report a validation error for unsupported element
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
vctx.addFatal("No customizations allowed", new ProblemLocation(ictx));
}
} else {
// report a validation error for unknown element
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
vctx.addFatal("Unknown element", new ProblemLocation(ictx));
}
ctx.skipElement();
return null;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/custom/SchemaRootBase.java 0000644 0001750 0001750 00000111630 11277626236 027545 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.custom;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.jibx.binding.model.BuiltinFormats;
import org.jibx.binding.model.FormatElement;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IUnmarshaller;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.schema.codegen.JavaType;
import org.jibx.schema.codegen.extend.ClassDecorator;
import org.jibx.schema.codegen.extend.DefaultNameConverter;
import org.jibx.schema.codegen.extend.NameConverter;
import org.jibx.schema.support.Conversions;
import org.jibx.schema.validation.ProblemLocation;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.ChainedMap;
import org.jibx.util.ReflectionUtilities;
import org.jibx.util.StringArray;
/**
* Base class for possible root customizations.
*
* @author Dennis M. Sosnoski
*/
public abstract class SchemaRootBase extends NestingCustomBase
{
private static final ClassDecorator[] EMPTY_DECORATORS_ARRAY = new ClassDecorator[0];
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes = new StringArray(new String[] { "binding-file-name",
"binding-per-schema", "delete-annotations", "enumeration-type", "generate-all", "import-docs", "inline-groups",
"line-width", "package", "prefer-inline", "prefix", "repeated-type", "show-schema", "structure-optional",
"use-inner" }, NestingCustomBase.s_allowedAttributes);
/** Default converter used if none set. */
private static final NameConverter s_defaultNameConverter = new DefaultNameConverter();
/** Default format name to definition map. */
private static final Map s_nameToFormat;
static {
s_nameToFormat = new HashMap();
for (int i = 0; i < BuiltinFormats.s_builtinFormats.length; i++) {
FormatElement format = BuiltinFormats.s_builtinFormats[i];
s_nameToFormat.put(format.getLabel(), format);
}
}
//
// Value set information
public static final int REPEAT_ARRAY = 0;
public static final int REPEAT_LIST = 1;
public static final int REPEAT_TYPED = 2;
public static final EnumSet s_repeatValues = new EnumSet(REPEAT_ARRAY,
new String[] { "array", "list", "typed"});
public static final int ENUM_JAVA5 = 0;
public static final int ENUM_SIMPLE = 1;
public static final EnumSet s_enumValues = new EnumSet(ENUM_JAVA5,
new String[] { "java5", "simple" });
//
// Instance data
/** Fully-qualified package name. */
private String m_package;
/** Generate one binding for each schema flag (binding per namespace if false). */
private Boolean m_bindingPerSchema;
/** Binding file name (only allowed if single namespace, null if derived from schema name). */
private String m_bindingFileName;
/** Prefix used for namespace (only allowed if single namespace, null if from schema). */
private String m_prefix;
/** Generate even unused global definitions. */
private Boolean m_generateAll;
/** Inline xs:group and xs:attributeGroup definitions by default. */
private Boolean m_inlineGroups;
/** Prefer inline definitions (separate classes for all if false). */
private Boolean m_preferInline;
/** Use inner classes for substructures (top-level classes for all if false). */
private Boolean m_useInner;
/** Delete annotations flag. */
private Boolean m_deleteAnnotations;
/** Convert schema documentation to JavaDocs in generated code flag. */
private Boolean m_importDocs;
/** Include schema fragments in generated class JavaDocs flag. */
private Boolean m_showSchema;
/** Force separate class for collection flag. */
private Boolean m_nullCollection;
/** Set references as optional structure where possible flag. */
private Boolean m_structureOptional;
/** Map from schema type name to Java type information (lazy create, null if not used at level). */
private Map m_schemaTypes;
/** Name converter instance (null if none set at level). */
private NameConverter m_nameConverter;
/** Inherit code generation class decorators from parent flag. */
private Boolean m_inheritDecorators;
/** Decorators to be used in code generation (null if none set at level). */
private List m_classDecorators;
/** Preferred maximum line width for generated code. */
private Integer m_lineWidth;
/** Code for repeated value representation (-1 if not set at level). */
private int m_repeatCode = -1;
/** Code for enumeration representation (-1 if not set at level). */
private int m_enumCode = -1;
/**
* Constructor.
*
* @param parent
*/
public SchemaRootBase(SchemaRootBase parent) {
super(parent);
}
/**
* Get parent customization (which will either be null, or another instance of this class).
*
* @return parent, or null if none
*/
public SchemaRootBase getRootParent() {
return (SchemaRootBase)getParent();
}
/**
* Check if a separate binding should be generated for each schema. The default is false if not
* overridden at any level.
*
* @return generate unused flag
*/
public boolean isBindingPerSchema() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_bindingPerSchema != null) {
return root.m_bindingPerSchema.booleanValue();
} else {
root = root.getRootParent();
}
}
return false;
}
/**
* Check whether unused definitions should be included in code generation. The default is true if not
* overridden at any level.
*
* @return generate unused flag
*/
public boolean isGenerateAll() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_generateAll != null) {
return root.m_generateAll.booleanValue();
} else {
root = root.getRootParent();
}
}
return true;
}
/**
* Check whether xs:group and xs:attributeGroup definitions should be inlined by default. The default is
* false if not overridden at any level.
*
* @return generate unused flag
*/
public boolean isInlineGroups() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_inlineGroups != null) {
return root.m_inlineGroups.booleanValue();
} else {
root = root.getRootParent();
}
}
return false;
}
/**
* Check whether inlining of components is preferred. The default is false if not overridden at any
* level.
*
* @return inline components flag
*/
public boolean isPreferInline() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_preferInline != null) {
return root.m_preferInline.booleanValue();
} else {
root = root.getRootParent();
}
}
return false;
}
/**
* Check whether inner classes are preferred for components used only by one definition. The default is
* true if not overridden at any level.
*
* @return inline components flag
*/
public boolean isUseInner() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_useInner != null) {
return root.m_useInner.booleanValue();
} else {
root = root.getRootParent();
}
}
return true;
}
/**
* Check whether annotations are to be deleted. The default is true if not overridden at any level.
*
* @return delete annotations flag
*/
public boolean isDeleteAnnotations() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_deleteAnnotations != null) {
return root.m_deleteAnnotations.booleanValue();
} else {
root = root.getRootParent();
}
}
return true;
}
/**
* Check whether schema documentation is to be used for JavaDocs in the generated code. The default is
* true if not overridden at any level.
*
* @return use schema documentation in JavaDocs flag
*/
public boolean isJavaDocDocumentation() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_importDocs != null) {
return root.m_importDocs.booleanValue();
} else {
root = root.getRootParent();
}
}
return true;
}
/**
* Check whether schema fragments matching a generated class are to be included in the class JavaDocs. The default
* is true if not overridden at any level.
*
* @return schema fragments in class JavaDocs flag
*/
public boolean isSchemaFragmentDocumentation() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_showSchema != null) {
return root.m_showSchema.booleanValue();
} else {
root = root.getRootParent();
}
}
return true;
}
/**
* Check whether collection holder (array, list, etc.) can be null. This is only relevant to
* collections using an optional wrapper element: If this flag is true a null collection
* holder indicates the element is missing; otherwise a class is created to wrap the collection holder, and a
* null for that class indicates the element is missing. The default is true if not
* overridden at any level.
* TODO: currently unsupported
*
* @return force collection wrapper flag
*/
public boolean isNullCollectionAllowed() {
// SchemaRootBase root = this;
// while (root != null) {
// if (root.m_nullCollection != null) {
// return root.m_nullCollection.booleanValue();
// } else {
// root = root.getRootParent();
// }
// }
return false;
}
/**
* Check whether references to classes with no associated element and all components optional should be made
* optional in the generated binding. The effect of making such class references optional is that the reference will
* be set null when unmarshalling if none of the components are present, and will be checked for
* null when marshalling. The default is true if not overridden at any level.
*
* @return prefer structure optional flag
*/
public boolean isStructureOptional() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_structureOptional != null) {
return root.m_structureOptional.booleanValue();
} else {
root = root.getRootParent();
}
}
return true;
}
/**
* Get the preferred maximum line width used for generated classes. The default is 80.
*
* @return line width
*/
public int getLineWidth() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_lineWidth != null) {
return root.m_lineWidth.intValue();
} else {
root = root.getRootParent();
}
}
return 80;
}
/**
* Get the repeated value representation type code to be applied for this schema or set of schemas. The default
* value is {@link #REPEAT_TYPED} if not overridden at any level.
*
* @return code
*/
public int getRepeatType() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_repeatCode >= 0) {
return root.m_repeatCode;
} else {
root = root.getRootParent();
}
}
return REPEAT_TYPED;
}
/**
* Set the repeated value representation type code.
*
* @param code type code, -1 if to be unset
*/
public void setRepeatType(int code) {
if (code != -1) {
s_repeatValues.checkValue(code);
}
m_repeatCode = code;
}
/**
* Get the repeated value representation text value set specifically for this element.
*
* @return text (null if not set)
*/
public String getRepeatedTypeText() {
if (m_repeatCode >= 0) {
return s_repeatValues.getName(m_repeatCode);
} else {
return null;
}
}
/**
* Set the repeated value representation text value. This method is provided only for use when unmarshalling.
*
* @param text (null if not set)
* @param ictx
*/
private void setRepeatedTypeText(String text, IUnmarshallingContext ictx) {
if (text != null) {
m_repeatCode = Conversions.convertEnumeration(text, s_repeatValues, "repeat-form", ictx);
}
}
/**
* Get the enumeration representation type code to be applied for this schema or set of schemas. The default
* value is {@link #ENUM_JAVA5} if not overridden at any level.
*
* @return code
*/
public int getEnumType() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_enumCode >= 0) {
return root.m_enumCode;
} else {
root = root.getRootParent();
}
}
return ENUM_JAVA5;
}
/**
* Set the enumeration representation type code.
*
* @param code type code, -1 if to be unset
*/
public void setEnumType(int code) {
if (code != -1) {
s_enumValues.checkValue(code);
}
m_enumCode = code;
}
/**
* Get the enumeration representation text value set specifically for this element.
*
* @return text (null if not set)
*/
public String getEnumerationTypeText() {
if (m_enumCode >= 0) {
return s_enumValues.getName(m_enumCode);
} else {
return null;
}
}
/**
* Set the enumeration representation text value. This method is provided only for use when unmarshalling.
*
* @param text (null if not set)
* @param ictx
*/
private void setEnumerationTypeText(String text, IUnmarshallingContext ictx) {
if (text != null) {
m_enumCode = Conversions.convertEnumeration(text, s_enumValues, "enum-form", ictx);
}
}
/**
* Get fully-qualified package name. This is inherited by nested schemas if set at any level.
*
* @return package (null if none set)
*/
public String getPackage() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_package != null) {
return root.m_package;
} else {
root = root.getRootParent();
}
}
return null;
}
/**
* Set fully-qualified package name. This is inherited by nested schemas if set at any level.
*
* @param pack (null if none)
*/
public void setPackage(String pack) {
m_package = pack;
}
/**
* Get binding definition file name. The binding name may not be set if more than one namespace is used in the
* schemas represented by this customization.
*
* @return name, null if to be derived from schema name
*/
public String getBindingFileName() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_bindingFileName != null) {
return root.m_bindingFileName;
} else {
root = root.getRootParent();
}
}
return null;
}
/**
* Get prefix used for namespace. The prefix may not be set if more than one namespace is used in the schemas
* represented by this customization.
*
* @return prefix, null if to be found from schema
*/
public String getPrefix() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_prefix != null) {
return root.m_prefix;
} else {
root = root.getRootParent();
}
}
return null;
}
/**
* Add schema type handling override.
*
* @param type
*/
private void addSchemaType(JavaType type) {
if (type != null) {
if (m_schemaTypes == null) {
m_schemaTypes = new ChainedMap(getSchemaTypes());
}
m_schemaTypes.put(type.getSchemaName(), type);
}
}
/**
* Get map from schema type local name to type information.
*
* @return map
*/
Map getSchemaTypes() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_schemaTypes != null) {
return root.m_schemaTypes;
} else {
root = root.getRootParent();
}
}
return JavaType.getTypeMap();
}
/**
* Set name converter to be used.
*
* @param nconv
* @param ictx
*/
private void setNameConverter(NameConverter nconv, IUnmarshallingContext ictx) {
if (nconv != null) {
if (m_nameConverter != null) {
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
vctx.addWarning("Repeated 'name-converter' element overrides previous setting", new ProblemLocation(ictx));
}
m_nameConverter = nconv;
}
}
/**
* Get name converter.
*
* @return converter (null if none defined)
*/
NameConverter getNameConverter() {
SchemaRootBase root = this;
while (root != null) {
if (root.m_nameConverter != null) {
return root.m_nameConverter;
} else {
root = root.getRootParent();
}
}
return s_defaultNameConverter;
}
/**
* Add a class decorator to the current list.
*
* @param decor
*/
private void addClassDecorator(ClassDecorator decor) {
if (decor != null) {
if (m_classDecorators == null) {
m_classDecorators = new ArrayList();
}
m_classDecorators.add(decor);
}
}
/**
* Get class decorators.
*
* @return decorators
*/
ClassDecorator[] getClassDecorators() {
SchemaRootBase root = this;
while (root != null) {
List decorators = root.m_classDecorators;
if (decorators != null) {
return (ClassDecorator[])decorators.toArray(new ClassDecorator[decorators.size()]);
} else if (root.m_inheritDecorators == null || root.m_inheritDecorators.booleanValue()) {
root = root.getRootParent();
} else {
break;
}
}
return EMPTY_DECORATORS_ARRAY;
}
/**
* Create an instance of the appropriate class decorator class, to be used for unmarshalling. This always uses the
* default constructor for the target class.
*
* @param ictx
* @return class decorator instance, or null if error
*/
private static ClassDecorator classDecoratorFactory(IUnmarshallingContext ictx) {
// get the class to be used for class decorator instance
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
UnmarshallingContext ctx = (UnmarshallingContext)ictx;
String cname = ctx.attributeText(null, "class", null);
if (cname == null) {
vctx.addError("Missing required 'class' attribute", new ProblemLocation(ctx));
} else {
try {
// make sure the class implements the required interface
Class clas = SchemaRootBase.class.getClassLoader().loadClass(cname);
if (ClassDecorator.class.isAssignableFrom(clas)) {
vctx.addError("Class " + cname + " does not implement the required IClassDecorator interface",
new ProblemLocation(ictx));
} else {
try {
return (ClassDecorator)clas.newInstance();
} catch (InstantiationException e) {
vctx.addError("Error creating instance of class " + cname + ": " + e.getMessage(),
new ProblemLocation(ictx));
} catch (IllegalAccessException e) {
vctx.addError("Unable to access constructor for class " + cname + ": " + e.getMessage(),
new ProblemLocation(ictx));
}
}
} catch (ClassNotFoundException e) {
vctx.addError("Unable to find class " + cname + " in classpath", new ProblemLocation(ictx));
}
}
return null;
}
/**
* Unmarshaller for schema-type elements.
*/
public static class SchemaTypeUnmarshaller implements IUnmarshaller
{
/** Actual element name used in binding. */
private static String ELEMENT_NAME = "schema-type";
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes = new StringArray(new String[] { "check-method",
"deserializer", "format-name", "java-class", "serializer", "type-name" });
/**
* Check for element present.
*
* @param ictx
* @return true if present, false if not
* @throws JiBXException on error
*/
public boolean isPresent(IUnmarshallingContext ictx) throws JiBXException {
return ictx.isAt(null, ELEMENT_NAME);
}
/**
* Unmarshal instance of element.
*
* @param obj ignored (new instance always created)
* @param ictx
* @return unmarshalled instance
* @throws JiBXException on error
*/
public Object unmarshal(Object obj, IUnmarshallingContext ictx) throws JiBXException {
// position to start tag and create instance to unmarshal
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
UnmarshallingContext ctx = (UnmarshallingContext)ictx;
ctx.parseToStartTag(null, ELEMENT_NAME);
// accumulate attribute values for constructor
String check = ctx.attributeText(null, "check-method", null);
String dser = ctx.attributeText(null, "deserializer", null);
String format = ctx.attributeText(null, "format-name", null);
String jclas = ctx.attributeText(null, "java-class", null);
String ser = ctx.attributeText(null, "serializer", null);
String stype = ctx.attributeText(null, "type-name");
boolean valid = true;
if (jclas == null && format == null) {
// need either 'java-class' or 'format-name', just report error and skip
vctx.addError("'java-class' attribute is required unless 'format-name' is used", ctx.getStackTop());
valid = false;
} else if (format != null) {
// check format for existence and consistency
FormatElement def = (FormatElement)s_nameToFormat.get(format);
if (def == null) {
vctx.addError('\'' + format + "' is not a valid built-in format name", ctx.getStackTop());
valid = false;
} else {
if (jclas == null) {
jclas = def.getTypeName();
}
}
}
// look through all attributes of current element
for (int i = 0; i < ctx.getAttributeCount(); i++) {
// check if nonamespace attribute is in the allowed set
String name = ctx.getAttributeName(i);
if (ctx.getAttributeNamespace(i).length() == 0) {
if (s_allowedAttributes.indexOf(name) < 0) {
vctx.addWarning("Undefined attribute " + name, ctx.getStackTop());
}
}
}
// skip content, and create and return object instance
ctx.skipElement();
if (valid) {
return new JavaType(stype, null, jclas, format, ser, dser, check);
} else {
return null;
}
}
}
/**
* Unmarshaller for extension elements. This expects to find a 'class' attribute giving the name of the class to be
* created, along with other attributes used to set properties on an instance of the class. The latter attributes
* are handled by converting the attribute name into a field (with an 'm_' prefix) or method (with a 'set' prefix)
* name, then storing the value to that field or method.
*/
public static abstract class ExtensionUnmarshaller implements IUnmarshaller
{
private String m_name;
/**
* Constructor.
*
* @param name local name for the element handled
*/
public ExtensionUnmarshaller(String name) {
m_name = name;
}
/**
* Instance creation method. This is called by the {@link #unmarshal(Object, IUnmarshallingContext)} method to
* create the actual object instance to be handled. Subclasses must implement this method to create the instance
* and perform any appropriate initialization.
*
* @param cname class name from element (null if not supplied)
* @param ctx unmarshalling context
* @return object instance to be unmarshalled, or null if error
*/
protected abstract Object createInstance(String cname, UnmarshallingContext ctx);
/**
* Check for element present.
*
* @param ictx
* @return true if present, false if not
* @throws JiBXException on error
*/
public boolean isPresent(IUnmarshallingContext ictx) throws JiBXException {
return ictx.isAt(null, m_name);
}
/**
* Unmarshal instance of element. This ignores the 'class' attribute, if present, since that's intended for use
* by the subclass.
*
* @param obj ignored (new instance always created)
* @param ictx
* @return unmarshalled instance
* @throws JiBXException on error
*/
public Object unmarshal(Object obj, IUnmarshallingContext ictx) throws JiBXException {
// position to start tag and create instance to unmarshal
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
UnmarshallingContext ctx = (UnmarshallingContext)ictx;
ctx.parseToStartTag(null, m_name);
obj = createInstance(ctx.attributeText(null, "class", null), ctx);
if (obj != null) {
// accumulate all the attribute name-value pairs
Map map = new HashMap();
for (int i = 0; i < ctx.getAttributeCount(); i++) {
String name = ctx.getAttributeName(i);
String value = ctx.getAttributeValue(i);
if (ctx.getAttributeNamespace(i).length() == 0) {
if (!"class".equals(name)) {
map.put(name, value);
}
} else {
vctx.addError("Unknown namespaced attribute '" + name + "'", new ProblemLocation(ctx));
}
}
// create and populate values on instance
try {
ReflectionUtilities.applyKeyValueMap(map, obj);
} catch (IllegalArgumentException e) {
vctx.addError(e.getMessage(), new ProblemLocation(ctx));
}
}
// skip element and return unmarshalled decorator instance
ctx.skipElement();
return obj;
}
}
/**
* Unmarshaller for name converter extension elements.
*/
public static class NameConverterUnmarshaller extends ExtensionUnmarshaller
{
/**
* Constructor.
*/
public NameConverterUnmarshaller() {
super("name-converter");
}
/**
* Create an instance of the appropriate name converter class, to be used for unmarshalling. This first looks
* for a constructor in the target class which takes an instance of the existing name converter class as an
* argument, and uses that constructor if found (passing the existing name converter, so that settings can be
* inherited). If there's no constructor matching the existing name converter class the default constructor is
* instead used.
*
* @param cname class name from element (null if not supplied)
* @param ctx unmarshalling context
* @return object
*/
protected Object createInstance(String cname, UnmarshallingContext ctx) {
// set the class to be used for name converter instance
ValidationContext vctx = (ValidationContext)ctx.getUserContext();
if (cname == null) {
cname = "org.jibx.schema.codegen.extend.DefaultNameConverter";
}
try {
// make sure the class implements the required interface
Class clas = SchemaRootBase.class.getClassLoader().loadClass(cname);
if (NameConverter.class.isAssignableFrom(clas)) {
try {
// check for existing name converter instance to pass to constructor
SchemaRootBase outer = (SchemaRootBase)ctx.getStackTop();
NameConverter prior = outer.getNameConverter();
if (prior != null) {
// try to create instance of new converter passing old converter
try {
Constructor cons = clas.getConstructor(new Class[] { prior.getClass() });
try {
return cons.newInstance(new Object[] { prior });
} catch (IllegalArgumentException e) { /* ignore failure */
} catch (InvocationTargetException e) {
vctx.addWarning("Failed passing existing name converter to constructor for class " +
cname + ": " + e.getMessage(), new ProblemLocation(ctx));
}
} catch (SecurityException e) { /* ignore failure */
} catch (NoSuchMethodException e) { /* ignore failure */ }
}
// just create instance using no-argument constructor
return clas.newInstance();
} catch (InstantiationException e) {
vctx.addError("Error creating instance of class " + cname + ": " + e.getMessage(),
new ProblemLocation(ctx));
} catch (IllegalAccessException e) {
vctx.addError("Unable to access constructor for class " + cname + ": " + e.getMessage(),
new ProblemLocation(ctx));
}
} else {
vctx.addError("Class " + cname + " does not implement the required NameConverter interface",
new ProblemLocation(ctx));
}
} catch (ClassNotFoundException e) {
vctx.addError("Unable to find class " + cname + " in classpath", new ProblemLocation(ctx));
}
return null;
}
}
/**
* Unmarshaller for class decorator extension elements.
*/
public static class ClassDecoratorUnmarshaller extends ExtensionUnmarshaller
{
/**
* Constructor.
*/
public ClassDecoratorUnmarshaller() {
super("class-decorator");
}
/**
* Create an instance of the appropriate class decorator class, to be used for unmarshalling. This always uses
* the default constructor for the specified class.
*
* @param cname class name from element (null if not supplied)
* @param ctx unmarshalling context
* @return object
*/
protected Object createInstance(String cname, UnmarshallingContext ctx) {
// check class to be used for class decorator instance
ValidationContext vctx = (ValidationContext)ctx.getUserContext();
if (cname == null) {
vctx.addError("Missing required 'class' attribute", new ProblemLocation(ctx));
} else {
try {
// make sure the class implements the required interface
Class clas = SchemaRootBase.class.getClassLoader().loadClass(cname);
if (ClassDecorator.class.isAssignableFrom(clas)) {
try {
return clas.newInstance();
} catch (InstantiationException e) {
vctx.addError("Error creating instance of class " + cname + ": " + e.getMessage(),
new ProblemLocation(ctx));
} catch (IllegalAccessException e) {
vctx.addError("Unable to access constructor for class " + cname + ": " + e.getMessage(),
new ProblemLocation(ctx));
}
} else {
vctx.addError("Class " + cname + " does not implement the required ClassDecorator interface",
new ProblemLocation(ctx));
}
} catch (ClassNotFoundException e) {
vctx.addError("Unable to find class " + cname + " in classpath", new ProblemLocation(ctx));
}
}
return null;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/custom/NestingCustomBase.java 0000644 0001750 0001750 00000036222 11276344044 030277 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.custom;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.QName;
import org.jibx.schema.elements.FacetElement;
import org.jibx.schema.elements.SchemaBase;
import org.jibx.schema.support.Conversions;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.LazyList;
import org.jibx.util.StringArray;
/**
* Base class for all standard schema customizations that can contain other customizations.
*
* @author Dennis M. Sosnoski
*/
public abstract class NestingCustomBase extends CustomBase implements TypeReplacer
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "any-handling", "choice-exposed", "choice-handling", "enforced-facets",
"ignored-facets", "type-substitutions", "union-exposed", "union-handling" });
//
// Value set information
public static final int ANY_DISCARD = 0;
public static final int ANY_DOM = 1;
public static final int ANY_MAPPED = 2;
public static final EnumSet s_anyValues = new EnumSet(ANY_DISCARD,
new String[] { "discard", "dom", "mapped"});
public static final int SELECTION_UNCHECKED = 0;
public static final int SELECTION_CHECKEDSET = 1;
public static final int SELECTION_CHECKEDBOTH = 2;
public static final int SELECTION_OVERRIDESET = 3;
public static final int SELECTION_OVERRIDEBOTH = 4;
public static final EnumSet s_selectionValues = new EnumSet(SELECTION_UNCHECKED,
new String[] { "stateless", "checkset", "checkboth", "overset", "overboth" });
//
// Bound fields.
/** List of type substitution pairs. */
private QName[] m_substitutions;
/** Mask for facets enforced at this level. */
private long m_enforcedFacetsMask;
/** Mask for facets ignored at this level. */
private long m_ignoredFacetsMask;
/** Expose choice selection state directly to user. */
private Boolean m_choiceExposed;
/** Code for xs:choice handling (-1 if not set at level). */
private int m_choiceCode = -1;
/** Expose union selection state directly to user. */
private Boolean m_unionExposed;
/** Code for xs:union handling (-1 if not set at level). */
private int m_unionCode = -1;
/** Code for xs:any representation (-1 if not set at level). */
private int m_anyCode = -1;
/** Child customizations. */
private final LazyList m_children;
//
// Constructed fields.
/** Map of type substitutions. */
private Map m_typeSubstitutionMap;
/** Mask for facets active at this level (all facets not in scope of an ignore state). */
private long m_activeFacetsMask;
/**
* Constructor.
*
* @param parent
*/
public NestingCustomBase(NestingCustomBase parent) {
super(parent);
m_children = new LazyList();
}
/**
* Get type substitution pairs list.
*
* @return substitutions
*/
public QName[] getSubstitutions() {
return m_substitutions;
}
/**
* Set type substitution pairs list.
*
* @param subs
*/
public void setSubstitutions(QName[] subs) {
m_substitutions = subs;
}
/**
* Set the list of facet elements to be enforced.
*
* @param facets
* @param ictx
*/
public void setEnforcedFacets(String[] facets, IUnmarshallingContext ictx) {
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
long mask = 0;
if (facets != null) {
for (int i = 0; i < facets.length; i++) {
String facet = facets[i];
int index = Arrays.binarySearch(FacetElement.FACET_ELEMENT_NAMES, facet);
if (index >= 0) {
mask |= SchemaBase.ELEMENT_MASKS[FacetElement.FACET_ELEMENT_INDEXES[index]];
} else {
vctx.addError("'" + facet + "' is not a facet name", this);
}
}
}
m_enforcedFacetsMask = mask;
}
/**
* Set the list of facet elements to be ignored.
*
* @param facets
* @param ictx
*/
public void setIgnoredFacets(String[] facets, IUnmarshallingContext ictx) {
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
long mask = 0;
if (facets != null) {
for (int i = 0; i < facets.length; i++) {
String facet = facets[i];
int index = Arrays.binarySearch(FacetElement.FACET_ELEMENT_NAMES, facet);
if (index >= 0) {
mask |= SchemaBase.ELEMENT_MASKS[FacetElement.FACET_ELEMENT_INDEXES[index]];
} else {
vctx.addError("'" + facet + "' is not a facet name", this);
}
}
}
m_ignoredFacetsMask = mask;
}
/**
* Get the bitmask of facet element flags to be processed.
*
* @return bitmask
*/
public long getActiveFacetsMask() {
return m_activeFacetsMask;
}
/**
* Get child customizations.
*
* @return children
*/
public LazyList getChildren() {
return m_children;
}
/**
* Set a type replacement.
*
* @param original
* @param replace
*/
protected void setReplacement(QName original, QName replace) {
m_typeSubstitutionMap.put(original, replace);
}
/**
* Get replacement type.
*
* @param qname
* @return replacement type (null if deletion; original type, if no replacement defined)
*/
public QName getReplacement(QName qname) {
if (m_typeSubstitutionMap.containsKey(qname)) {
return (QName)m_typeSubstitutionMap.get(qname);
} else {
return qname;
}
}
/**
* Get the xs:any handling type code to be applied for this component and all nested components. The default value
* is {@link #ANY_DOM} if not overridden at any level.
*
* @return code
*/
public int getAnyType() {
NestingCustomBase nest = this;
while (nest != null) {
if (nest.m_anyCode >= 0) {
return nest.m_anyCode;
} else {
nest = nest.getParent();
}
}
return ANY_DOM;
}
/**
* Set the xs:any handling type code.
*
* @param code handling code, -1 if to be unset
*/
public void setAnyType(int code) {
if (code != -1) {
s_anyValues.checkValue(code);
}
m_anyCode = code;
}
/**
* Get the xs:any handling text value set specifically for this element.
*
* @return text (null if not set)
*/
public String getAnyHandling() {
if (m_anyCode >= 0) {
return s_anyValues.getName(m_anyCode);
} else {
return null;
}
}
/**
* Set the xs:any handling text value. This method is provided only for use when unmarshalling.
*
* @param text (null if not set)
* @param ictx
*/
private void setAnyHandling(String text, IUnmarshallingContext ictx) {
if (text != null) {
m_anyCode = Conversions.convertEnumeration(text, s_anyValues, "any-handling", ictx);
}
}
/**
* Check whether xs:choice selection states should be exposed to the user. The default is false if not
* overridden at any level.
*
* @return expose choice state flag
*/
public boolean isChoiceExposed() {
NestingCustomBase nest = this;
while (nest != null) {
if (nest.m_choiceExposed != null) {
return nest.m_choiceExposed.booleanValue();
} else {
nest = nest.getParent();
}
}
return false;
}
/**
* Get the xs:choice handling type code to be applied for this component and all nested components. The default
* value is {@link #SELECTION_CHECKEDSET} if not overridden at any level.
*
* @return code
*/
public int getChoiceType() {
NestingCustomBase nest = this;
while (nest != null) {
if (nest.m_choiceCode >= 0) {
return nest.m_choiceCode;
} else {
nest = nest.getParent();
}
}
return SELECTION_CHECKEDSET;
}
/**
* Set the xs:choice handling type code.
*
* @param code handling code, -1 if to be unset
*/
public void setChoiceType(int code) {
if (code != -1) {
s_selectionValues.checkValue(code);
}
m_choiceCode = code;
}
/**
* Get the xs:choice handling text value set specifically for this element.
*
* @return text (null if not set)
*/
public String getChoiceHandling() {
if (m_choiceCode >= 0) {
return s_selectionValues.getName(m_choiceCode);
} else {
return null;
}
}
/**
* Set the xs:choice handling text value. This method is provided only for use when unmarshalling.
*
* @param text (null if not set)
* @param ictx
*/
private void setChoiceHandling(String text, IUnmarshallingContext ictx) {
if (text != null) {
m_choiceCode = Conversions.convertEnumeration(text, s_selectionValues, "choice-handling", ictx);
}
}
/**
* Check whether xs:union selection states should be exposed to the user. The default is false if not
* overridden at any level.
*
* @return expose union state flag
*/
public boolean isUnionExposed() {
NestingCustomBase nest = this;
while (nest != null) {
if (nest.m_unionExposed != null) {
return nest.m_unionExposed.booleanValue();
} else {
nest = nest.getParent();
}
}
return false;
}
/**
* Get the xs:union handling type code to be applied for this component and all nested components. The default
* value is {@link #SELECTION_CHECKEDSET} if not overridden at any level.
*
* @return code
*/
public int getUnionType() {
NestingCustomBase nest = this;
while (nest != null) {
if (nest.m_unionCode >= 0) {
return nest.m_unionCode;
} else {
nest = nest.getParent();
}
}
return SELECTION_CHECKEDSET;
}
/**
* Set the xs:union handling type code.
*
* @param code handling code, -1 if to be unset
*/
public void setUnionType(int code) {
if (code != -1) {
s_selectionValues.checkValue(code);
}
m_unionCode = code;
}
/**
* Get the xs:union handling text value set specifically for this element.
*
* @return text (null if not set)
*/
public String getUnionHandling() {
if (m_unionCode >= 0) {
return s_selectionValues.getName(m_unionCode);
} else {
return null;
}
}
/**
* Set the xs:union handling text value. This method is provided only for use when unmarshalling.
*
* @param text (null if not set)
* @param ictx
*/
private void setUnionHandling(String text, IUnmarshallingContext ictx) {
if (text != null) {
m_unionCode = Conversions.convertEnumeration(text, s_selectionValues, "union-handling", ictx);
}
}
/**
* Check whether xs:attribute definitions should always be inlined, even when used in multiple locations. The
* default is false if not overridden at any level.
* TODO: implement in customizations
*
* @return inline attribute flag
*/
public boolean isAttributeInlined() {
/* NestingCustomBase nest = this;
while (nest != null) {
if (nest.m_choiceExposed != null) {
return nest.m_choiceExposed.booleanValue();
} else {
nest = nest.getParent();
}
} */
return false;
}
/**
* Validate and finalize customization information. This creates a new type substitution map and active facets mask,
* or inherits unchanged values from the parent customization.
*
* @param vctx validation context
* @return true if valid, false if not
*/
public boolean validate(ValidationContext vctx) {
NestingCustomBase parent = getParent();
if (m_substitutions == null || m_substitutions.length == 0) {
m_typeSubstitutionMap = parent.m_typeSubstitutionMap;
} else if ((m_substitutions.length % 2) == 0) {
if (parent == null) {
m_typeSubstitutionMap = new HashMap();
} else {
m_typeSubstitutionMap = new HashMap(parent.m_typeSubstitutionMap);
}
for (int i = 0; i < m_substitutions.length; i += 2) {
m_typeSubstitutionMap.put(m_substitutions[i], m_substitutions[i+1]);
}
} else {
vctx.addError("Type substitution list must be pairs, not an odd number of names", this);
}
// TODO: implement the facet handling
m_activeFacetsMask = SchemaBase.ELEMENT_MASKS[SchemaBase.ENUMERATION_TYPE];
return true;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/custom/SchemasetCustom.java 0000644 0001750 0001750 00000026020 11414120464 027774 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.custom;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import org.apache.log4j.Logger;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.elements.SchemaElement;
import org.jibx.schema.validation.ProblemHandler;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.schema.validation.ValidationProblem;
import org.jibx.util.LazyList;
import org.jibx.util.NameUtilities;
import org.jibx.util.StringArray;
/**
* Customization information for a set of schemas.
*
* @author Dennis M. Sosnoski
*/
public class SchemasetCustom extends SchemaRootBase
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(SchemasetCustom.class.getName());
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "names", "namespaces" }, SchemaRootBase.s_allowedAttributes);
//
// Unmarshalled data
/** Schema name patterns. */
private String[] m_names;
/** Schema namespace patterns. */
private String[] m_namespaces;
//
// Instance data
/** Map from schema identifier to customization. */
private final Map m_schemaMap;
/**
* Normal constructor.
*
* @param parent
*/
public SchemasetCustom(SchemasetCustom parent) {
super(parent);
m_schemaMap = new HashMap();
}
/**
* Constructor with single schema customization as content.
*
* @param child
*/
public SchemasetCustom(SchemaCustom child) {
super(null);
child.setParent(this);
getChildren().add(child);
m_schemaMap = new HashMap();
}
/**
* Get schema name match patterns.
*
* @return names (null if not set)
*/
public String[] getNames() {
return m_names;
}
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
*/
private void preSet(IUnmarshallingContext uctx) {
validateAttributes(uctx, s_allowedAttributes);
}
/**
* Check if a schema is included in this set.
*
* @param name schema file name
* @param schema actual schema
* @return true if in set, false if not
*/
public boolean isInSet(String name, SchemaElement schema) {
// check for match on file name
boolean match = true;
if (m_names != null) {
match = false;
for (int i = 0; i < m_names.length; i++) {
if (NameUtilities.isPatternMatch(name, m_names[i])) {
match = true;
break;
}
}
}
// check for match on effective namespace
if (m_namespaces != null) {
match = false;
String ns = schema.getEffectiveNamespace();
if (ns == null) {
ns = "";
}
for (int i = 0; i < m_namespaces.length; i++) {
if (NameUtilities.isPatternMatch(ns, m_namespaces[i])) {
match = true;
break;
}
}
}
// return 'and' of two tests
return match;
}
/**
* Get existing schema customization information.
*
* @param id schema identifier
* @return customization
*/
public SchemaCustom getCustomization(String id) {
return (SchemaCustom)m_schemaMap.get(id);
}
/**
* Get schema customization information, creating it if it doesn't already exist.
*
* @param name schema file name
* @param id unique identifier for schema
* @param schema actual schema
* @param vctx validation context for reporting errors
* @return customization
*/
public SchemaCustom forceCustomization(String name, String id, SchemaElement schema, ValidationContext vctx) {
SchemaCustom custom = (SchemaCustom)m_schemaMap.get(name);
if (custom == null) {
// check for unique match to schema customization
for (int i = 0; i < getChildren().size(); i++) {
SchemaRootBase child = (SchemaRootBase)getChildren().get(i);
if (child instanceof SchemaCustom && ((SchemaCustom)child).checkMatch(name, schema)) {
if (custom == null) {
custom = (SchemaCustom)child;
} else {
vctx.addError("Multiple matches to schema " + name + " (first match " +
ValidationProblem.componentDescription(custom) + ')', child);
}
}
}
// create default customization if no match found
if (custom == null) {
custom = new SchemaCustom(this);
}
// add customization to map and link to schema
m_schemaMap.put(id, custom);
custom.setSchema(name, schema);
schema.setExtension(custom);
}
return custom;
}
/**
* Factory used during unmarshalling.
*
* @param ictx
* @return instance
*/
private static SchemasetCustom factory(IUnmarshallingContext ictx) {
return new SchemasetCustom((SchemasetCustom)getContainingObject(ictx));
}
/**
* Recursively check that each schema customization has been matched to a schema. A warning is generated for any
* customization without a matching schema.
*
* @param vctx
*/
public void checkSchemas(ValidationContext vctx) {
// check for unique match to schema customization
for (int i = 0; i < getChildren().size(); i++) {
SchemaRootBase child = (SchemaRootBase)getChildren().get(i);
if (child instanceof SchemaCustom) {
SchemaCustom custom = (SchemaCustom)child;
if (custom.getSchema() == null) {
StringBuffer buff = new StringBuffer("No schema loaded for customization");
if (custom.getName() != null) {
buff.append(" with name ");
buff.append(custom.getName());
} else if (custom.getNamespace() != null) {
buff.append(" with namespace ");
buff.append(custom.getNamespace());
}
vctx.addWarning(buff.toString(), custom);
}
} else if (child instanceof SchemasetCustom) {
((SchemasetCustom)child).checkSchemas(vctx);
}
}
}
/**
* Validate and finalize customization information. This override of the base class implementation also invokes the
* same method on any nested schemasets in order to make sure that the type substitution map and active facets mask
* will be available for use by nested schemas.
*
* @param vctx validation context
* @return true if valid, false if not
*/
public boolean validate(ValidationContext vctx) {
boolean valid = super.validate(vctx);
if (valid) {
LazyList children = getChildren();
for (int i = 0; i < children.size(); i++) {
Object child = children.get(i);
if (child instanceof SchemasetCustom) {
if (!((SchemasetCustom)child).validate(vctx)) {
valid = false;
}
}
}
}
return valid;
}
/**
* Load a customizations file. The specified file must exist and have as root element either a <schema-set> or
* <schema> element.
*
* @param path customization file path (null if none)
* @param handler validation problem handler
* @return unmarshalled customizations, or null if errors
* @throws JiBXException
* @throws IOException
*/
public static SchemasetCustom loadCustomizations(String path, ProblemHandler handler)
throws JiBXException, IOException {
// load customizations and check for errors
SchemasetCustom custom = null;
ValidationContext vctx = new ValidationContext();
if (path == null) {
custom = new SchemasetCustom((SchemasetCustom)null);
} else {
// unmarshal either a or element
IBindingFactory fact = BindingDirectory.getFactory(SchemasetCustom.class);
IUnmarshallingContext ictx = fact.createUnmarshallingContext();
FileInputStream is = new FileInputStream(path);
ictx.setDocument(is, null);
ictx.setUserContext(vctx);
Object obj = ictx.unmarshalElement();
if (obj instanceof SchemasetCustom) {
custom = (SchemasetCustom)obj;
} else if (obj instanceof SchemaCustom) {
custom = new SchemasetCustom((SchemaCustom)obj);
} else {
throw new IOException("Customization document root element must be 'schema-set' or 'schema'");
}
}
if (vctx.reportProblems(handler)) {
return null;
}
return custom;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/custom/CustomBase.java 0000644 0001750 0001750 00000010615 11125560044 026736 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.custom;
import java.util.Collection;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Base class for all schema customizations. This defines a way to navigate up the tree of nested customizations without
* making assumptions about the specific type of the containing components.
*
* @author Dennis M. Sosnoski
*/
public class CustomBase
{
/** Parent element (null if none). */
private NestingCustomBase m_parent;
/**
* Constructor.
*
* @param parent
*/
public CustomBase(NestingCustomBase parent) {
m_parent = parent;
}
/**
* Get container.
*
* @return container
*/
public NestingCustomBase getParent() {
return m_parent;
}
/**
* Set container.
*
* @param parent
*/
protected void setParent(NestingCustomBase parent) {
m_parent = parent;
}
/**
* Get schema customizations parent.
*
* @return schema customization
*/
public SchemaRootBase getSchemaRoot() {
NestingCustomBase parent = m_parent;
while (!(parent instanceof SchemaRootBase)) {
parent = parent.getParent();
}
return (SchemaRootBase)parent;
}
/**
* Validate attributes of element. This is designed to be called during unmarshalling as part of the pre-set method
* processing when a subclass instance is being created.
*
* @param ictx unmarshalling context
* @param attrs attributes array
*/
protected void validateAttributes(IUnmarshallingContext ictx, StringArray attrs) {
// setup for attribute access
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
UnmarshallingContext uctx = (UnmarshallingContext)ictx;
// loop through all attributes of current element
for (int i = 0; i < uctx.getAttributeCount(); i++) {
// check if nonamespace attribute is in the allowed set
String name = uctx.getAttributeName(i);
if (uctx.getAttributeNamespace(i).length() == 0) {
if (attrs.indexOf(name) < 0) {
vctx.addWarning("Undefined attribute " + name, this);
}
}
}
}
/**
* Gets the parent element link from the unmarshalling stack. This method is for use by factories during
* unmarshalling.
*
* @param ictx unmarshalling context
* @return containing class
*/
protected static Object getContainingObject(IUnmarshallingContext ictx) {
Object parent = ictx.getStackTop();
if (parent instanceof Collection) {
parent = ictx.getStackObject(1);
}
return parent;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/custom/ComponentExtension.java 0000644 0001750 0001750 00000136711 11424513142 030535 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.custom;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
import org.apache.log4j.Logger;
import org.jibx.runtime.QName;
import org.jibx.schema.IArity;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.elements.AttributeElement;
import org.jibx.schema.elements.AttributeGroupRefElement;
import org.jibx.schema.elements.ChoiceElement;
import org.jibx.schema.elements.CommonCompositorDefinition;
import org.jibx.schema.elements.CommonTypeDefinition;
import org.jibx.schema.elements.CommonTypeDerivation;
import org.jibx.schema.elements.ComplexExtensionElement;
import org.jibx.schema.elements.ComplexRestrictionElement;
import org.jibx.schema.elements.ComplexTypeElement;
import org.jibx.schema.elements.ElementElement;
import org.jibx.schema.elements.FilteredSegmentList;
import org.jibx.schema.elements.GroupRefElement;
import org.jibx.schema.elements.ListElement;
import org.jibx.schema.elements.OpenAttrBase;
import org.jibx.schema.elements.SchemaBase;
import org.jibx.schema.elements.SequenceElement;
import org.jibx.schema.elements.SimpleExtensionElement;
import org.jibx.schema.elements.SimpleRestrictionElement;
import org.jibx.schema.elements.SimpleTypeElement;
import org.jibx.schema.elements.UnionElement;
import org.jibx.schema.support.SchemaTypes;
import org.jibx.schema.types.Count;
import org.jibx.schema.validation.ValidationContext;
/**
* Extension information for all schema components other than the schema element itself. This is the basic extension
* which associates schema components with values or classes for code generation.
*
* @author Dennis M. Sosnoski
*/
public class ComponentExtension extends BaseExtension
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(ComponentExtension.class.getName());
/** Containing global definition extension. */
private final GlobalExtension m_global;
/** Component dropped from schema definition. */
private boolean m_removed;
/** Optional component flag. */
private boolean m_optional;
/** Repeated component flag. */
private boolean m_repeated;
/** Customization information for this component. */
private ComponentCustom m_custom;
/** Override for type specified in schema (null if none). */
private QName m_overrideType;
/** Number of times a component is used in code generation. */
private int m_useCount;
/**
* Constructor.
*
* @param comp
* @param global containing global definition extension (null allowed only as special case when
* calling this constructor from the global extension subclass constructor)
*/
public ComponentExtension(OpenAttrBase comp, GlobalExtension global) {
super(comp);
m_global = global == null ? (GlobalExtension)this : global;
if (comp instanceof IArity) {
// element can only be optional or repeated when embedded, but no need to check since counts are forbidden
// on a global definition
IArity particle = (IArity)comp;
m_repeated = SchemaUtils.isRepeated(particle);
if (comp.type() == SchemaBase.ELEMENT_TYPE) {
m_optional = SchemaUtils.isOptionalElement((ElementElement)comp);
} else {
m_optional = SchemaUtils.isOptional(particle);
}
} else if (comp.type() == SchemaBase.ATTRIBUTE_TYPE) {
// attribute can never be repeated, and can only be optional when embedded (rather than a global definition)
m_repeated = false;
m_optional = global != null && ((AttributeElement)comp).getUse() == AttributeElement.OPTIONAL_USE;
}
}
/**
* Check if component to be removed from schema.
*
* @return removed flag
*/
public boolean isRemoved() {
return m_removed;
}
/**
* Set flag for component to be removed from schema.
*
* @param removed
*/
public void setRemoved(boolean removed) {
m_removed = removed;
}
/**
* Check if component is to be ignored.
*
* @return ignored flag
*/
public boolean isIgnored() {
if (m_custom == null) {
return false;
} else {
return m_custom.isIgnored();
}
}
/**
* Check if optional component.
*
* @return optional
*/
public boolean isOptional() {
return m_optional;
}
/**
* Set optional component.
*
* @param optional
*/
public void setOptional(boolean optional) {
m_optional = optional;
}
/**
* Check if repeated component.
*
* @return repeated
*/
public boolean isRepeated() {
return m_repeated;
}
/**
* Set repeated component.
*
* @param repeated
*/
public void setRepeated(boolean repeated) {
m_repeated = repeated;
}
/**
* Check if schema component is to be generated inline.
*
* @return true if inlined, false if not
*/
public boolean isInlined() {
if (m_custom == null) {
return false;
} else {
return m_custom.isInlined();
}
}
/**
* Check if schema component is to be generated as a separate class.
*
* @return true if separate class, false if not
*/
public boolean isSeparateClass() {
if (m_custom == null) {
return false;
} else {
return m_custom.isSeparateClass();
}
}
/**
* Get the containing global extension.
*
* @return global
*/
public GlobalExtension getGlobal() {
return m_global;
}
/**
* Get override type.
*
* @return type name (null if none)
*/
public QName getOverrideType() {
return m_overrideType;
}
/**
* Set override type.
*
* @param qname type name (null if none)
*/
public void setOverrideType(QName qname) {
m_overrideType = qname;
}
/**
* Increment the use count for the component.
*
* @return incremented use count
*/
public int incrementUseCount() {
return ++m_useCount;
}
/**
* Get the use count for the component.
*
* @return use count
*/
public int getUseCount() {
return m_useCount;
}
/**
* Get name to be used for generated class.
*
* @return class name (null if not set)
*/
public String getClassName() {
if (m_custom == null) {
return null;
} else {
return m_custom.getClassName();
}
}
/**
* Get base name for corresponding property.
*
* @return property name (null if not set)
*/
public String getBaseName() {
if (m_custom == null) {
return null;
} else {
return m_custom.getBaseName();
}
}
/**
* Get customization information for this component.
*
* @return custom
*/
ComponentCustom getCustom() {
return m_custom;
}
/**
* Set customization information for this component.
*
* @param custom
*/
void setCustom(ComponentCustom custom) {
m_custom = custom;
}
/**
* Get the innermost customization which applies to this component.
*
* @return customization
*/
private NestingCustomBase getContainingCustom() {
if (m_custom == null) {
Object extension = getComponent().getParent().getExtension();
if (extension instanceof ComponentExtension) {
return ((ComponentExtension)extension).getContainingCustom();
} else {
return ((SchemaExtension)extension).getCustom();
}
} else {
return m_custom;
}
}
/**
* Get the xs:any handling type code to be applied for this component. The default value is
* {@link NestingCustomBase#ANY_DOM} if not overridden at any level.
*
* @return code
*/
public int getAnyType() {
return getContainingCustom().getAnyType();
}
/**
* Get the xs:choice handling type code to be applied for this component. The default value is
* {@link NestingCustomBase#SELECTION_CHECKEDSET} if not overridden at any level.
*
* @return code
*/
public int getChoiceType() {
return getContainingCustom().getChoiceType();
}
/**
* Check if xs:choice selection state should be exposed for this component.
*
* @return exposed flag
*/
public boolean isChoiceExposed() {
return getContainingCustom().isChoiceExposed();
}
/**
* Get the xs:union handling type code to be applied for this component. The default value is
* {@link NestingCustomBase#SELECTION_CHECKEDSET} if not overridden at any level.
*
* @return code
*/
public int getUnionType() {
return getContainingCustom().getUnionType();
}
/**
* Check if xs:union selection state should be exposed for this component.
*
* @return exposed flag
*/
public boolean isUnionExposed() {
return getContainingCustom().isUnionExposed();
}
/**
* Check for type substitution on a type reference, then record the reference.
* TODO: how to handle substitutions across namespaces? the problem here is that the returned name needs to be
* correct in the use context, which may be using a different namespace for the same definition (due to includes of
* no-namespace schemas into a namespaced schema). the current code is only an interim fix that will not always work
*
* @param type original type
* @param vctx validation context
* @return replacement type (may be the same as the original type; null if to be deleted)
*/
private QName replaceAndReference(QName type, ValidationContext vctx) {
QName repl = getReplacementType(type);
if (repl != type && s_logger.isDebugEnabled()) {
s_logger.debug("Replacing type " + type + " with type " + repl + " in component " +
SchemaUtils.describeComponent(getComponent()));
}
while (repl != null) {
CommonTypeDefinition def = vctx.findType(repl);
if (def == null) {
// try substituting the original namespace, to work with no-namespace schemas
if (repl.getUri() == null && type.getUri() != null) {
repl = new QName(type.getUri(), repl.getName());
def = vctx.findType(repl);
}
if (def == null) {
throw new IllegalStateException("Internal error - type definition not found");
}
}
GlobalExtension exten = (GlobalExtension)def.getExtension();
if (exten == null) {
if (s_logger.isDebugEnabled()) {
s_logger.debug("No extension found for referenced type " + SchemaUtils.describeComponent(def));
}
return repl;
} else {
if (exten.isRemoved()) {
if (s_logger.isDebugEnabled()) {
s_logger.debug("Reference to deleted type " + SchemaUtils.describeComponent(def));
}
return null;
} else {
if (exten.getOverrideType() == null) {
exten.addReference(this);
m_global.addDependency(exten);
return repl;
} else {
repl = exten.getOverrideType();
}
}
}
}
return repl;
}
/**
* Check a reference to a component. If the reference component has been deleted this just returns
* false. If the component has not been deleted it counts the reference on that component, and records
* the dependency from this component before returning true. For convenience, this may be called with a
* null argument, which just returns true.
*
* @param comp component (call ignored if null)
* @return true if reference to be kept, false if deleted
*/
private boolean checkReference(OpenAttrBase comp) {
if (comp != null) {
GlobalExtension exten = (GlobalExtension)comp.getExtension();
if (exten == null) {
if (s_logger.isDebugEnabled()) {
s_logger.debug("No extension found for referenced component " +
SchemaUtils.describeComponent(comp));
}
} else {
if (exten.isRemoved()) {
if (s_logger.isDebugEnabled()) {
s_logger.debug("Referenced to deleted component " + SchemaUtils.describeComponent(comp));
}
return false;
} else {
exten.addReference(this);
m_global.addDependency(exten);
}
}
}
return true;
}
/**
* Remove a child element. This checks to make sure the removal is valid, and also handles logging of the change.
*
* @param index
*/
private void removeChild(int index) {
SchemaBase child = getComponent().getChild(index);
switch (child.type())
{
case SchemaBase.ALL_TYPE:
case SchemaBase.ANY_TYPE:
case SchemaBase.ANYATTRIBUTE_TYPE:
case SchemaBase.ATTRIBUTE_TYPE:
case SchemaBase.ATTRIBUTEGROUP_TYPE:
case SchemaBase.CHOICE_TYPE:
case SchemaBase.COMPLEXTYPE_TYPE:
case SchemaBase.ELEMENT_TYPE:
case SchemaBase.ENUMERATION_TYPE:
case SchemaBase.FRACTIONDIGITS_TYPE:
case SchemaBase.GROUP_TYPE:
case SchemaBase.LENGTH_TYPE:
case SchemaBase.MAXEXCLUSIVE_TYPE:
case SchemaBase.MAXINCLUSIVE_TYPE:
case SchemaBase.MAXLENGTH_TYPE:
case SchemaBase.MINEXCLUSIVE_TYPE:
case SchemaBase.MININCLUSIVE_TYPE:
case SchemaBase.MINLENGTH_TYPE:
case SchemaBase.PATTERN_TYPE:
case SchemaBase.SEQUENCE_TYPE:
case SchemaBase.SIMPLETYPE_TYPE:
case SchemaBase.TOTALDIGITS_TYPE:
case SchemaBase.WHITESPACE_TYPE:
{
// definition component - just delete from the parent structure
getComponent().detachChild(index);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Removed component " + SchemaUtils.describeComponent(child) +
" as per extension");
}
break;
}
default:
throw new IllegalStateException("Internal error: element type '" + child.name() +
"' cannot be deleted");
}
}
/**
* Apply extensions to schema definition component, deleting components flagged for skipping and substituting types
* as configured. This code is not intended to handle the deletion of global definition components, which should be
* removed separately.
*
* @param vctx validation context
*/
public void applyAndCountUsage(ValidationContext vctx) {
// handle type substitutions for this component
OpenAttrBase component = getComponent();
boolean delete = false;
switch (component.type())
{
case SchemaBase.ATTRIBUTE_TYPE:
{
if (isIgnored()) {
delete = true;
} else {
AttributeElement attr = ((AttributeElement)component);
if (m_overrideType != null) {
attr.setType(m_overrideType);
}
QName type = attr.getType();
if (type == null) {
AttributeElement ref = attr.getReference();
if (ref != null) {
delete = !checkReference(ref);
} else if (!attr.isInlineType()) {
attr.setType(SchemaTypes.ANY_SIMPLE_TYPE.getQName());
}
} else {
QName repl = replaceAndReference(type, vctx);
if (repl == null) {
// TODO optionally make sure the attribute is optional?
delete = true;
} else if (repl != type) {
attr.setType(repl);
}
}
}
break;
}
case SchemaBase.ATTRIBUTEGROUP_TYPE:
{
if (component instanceof AttributeGroupRefElement) {
delete = !checkReference(((AttributeGroupRefElement)component).getReference());
}
break;
}
case SchemaBase.ELEMENT_TYPE:
{
ElementElement elem = ((ElementElement)component);
if (isIgnored()) {
// reference or definition determines handling
QName ref = elem.getRef();
if (ref == null) {
// definition, just delete all content
for (int i = 0; i < elem.getChildCount(); i++) {
elem.detachChild(i);
}
elem.compactChildren();
} else {
// reference may be to other namespace, so convert to qualified name string
StringBuffer buff = new StringBuffer();
buff.append('{');
if (ref.getUri() != null) {
buff.append(ref.getUri());
}
buff.append('}');
buff.append(ref.getName());
elem.setName(buff.toString());
elem.setRef(null);
}
elem.setType(SchemaTypes.ANY_TYPE.getQName());
} else {
if (m_overrideType != null) {
elem.setType(m_overrideType);
}
QName type = elem.getType();
if (type == null) {
delete = !checkReference(elem.getReference());
} else {
QName repl = replaceAndReference(type, vctx);
if (repl == null) {
// TODO optionally make sure the element is optional?
delete = true;
} else if (repl != type) {
elem.setType(repl);
}
}
}
break;
}
case SchemaBase.EXTENSION_TYPE:
case SchemaBase.RESTRICTION_TYPE:
{
CommonTypeDerivation deriv = (CommonTypeDerivation)component;
QName type = deriv.getBase();
if (type != null) {
QName repl = replaceAndReference(type, vctx);
if (repl == null) {
delete = true;
} else if (repl != type) {
deriv.setBase(repl);
}
}
break;
}
case SchemaBase.GROUP_TYPE:
{
if (component instanceof GroupRefElement) {
delete = !checkReference(((GroupRefElement)component).getReference());
}
break;
}
case SchemaBase.LIST_TYPE:
{
ListElement list = ((ListElement)component);
/* // not currently supported - is it needed?
if (m_overrideType != null) {
list.setItemType(m_overrideType);
} */
QName type = list.getItemType();
if (type != null) {
QName repl = replaceAndReference(type, vctx);
if (repl == null) {
delete = true;
} else if (repl != type) {
list.setItemType(repl);
}
}
break;
}
case SchemaBase.UNION_TYPE:
{
UnionElement union = ((UnionElement)component);
QName[] types = union.getMemberTypes();
if (types != null) {
ArrayList repls = new ArrayList();
boolean changed = false;
for (int i = 0; i < types.length; i++) {
QName type = types[i];
QName repl = replaceAndReference(type, vctx);
changed = changed || repl != type;
if (repl != null) {
repls.add(repl);
}
}
if (changed) {
if (repls.size() > 0) {
union.setMemberTypes((QName[])repls.toArray(new QName[repls.size()]));
} else {
union.setMemberTypes(null);
}
}
}
break;
}
}
if (delete) {
// raise deletion to containing removable component
SchemaBase parent = component;
SchemaBase remove = null;
loop: while (parent != null) {
switch (parent.type())
{
case SchemaBase.ATTRIBUTE_TYPE:
case SchemaBase.ATTRIBUTEGROUP_TYPE:
case SchemaBase.ELEMENT_TYPE:
case SchemaBase.GROUP_TYPE:
remove = parent;
break loop;
case SchemaBase.COMPLEXTYPE_TYPE:
case SchemaBase.SIMPLETYPE_TYPE:
remove = parent;
parent = parent.getParent();
break;
default:
if (remove == null) {
parent = parent.getParent();
break;
} else {
break loop;
}
}
}
if (remove == null) {
throw new IllegalStateException("Internal error: no removable ancestor found for component "
+ SchemaUtils.describeComponent(component));
} else {
((ComponentExtension)remove.getExtension()).setRemoved(true);
}
} else {
// process all child component extensions
boolean modified = false;
for (int i = 0; i < component.getChildCount(); i++) {
SchemaBase child = component.getChild(i);
ComponentExtension exten = (ComponentExtension)child.getExtension();
if (!exten.isRemoved()) {
exten.applyAndCountUsage(vctx);
}
if (exten.isRemoved()) {
removeChild(i);
modified = true;
}
}
if (modified) {
component.compactChildren();
}
}
}
/**
* Try to replace type definition with substitute type from derivation. If
*
* @param lead prefix text for indentation of logging messages
* @param topcomp schema component being normalized
* @param childcomp current child of schema component being normalized
* @param derive type derivation supplying substitute type
* @return true if type modified, false if not
*/
private boolean substituteTypeDerivation(String lead, OpenAttrBase topcomp, OpenAttrBase childcomp,
CommonTypeDerivation derive) {
SchemaBase parent = topcomp;
while (parent != null) {
switch (parent.type())
{
case SchemaBase.ATTRIBUTE_TYPE:
{
// set the attribute type to the specified type
AttributeElement attr = (AttributeElement)parent;
attr.setType(derive.getBase());
return true;
}
case SchemaBase.COMPLEXTYPE_TYPE:
{
if (parent.isGlobal()) {
GlobalExtension global = (GlobalExtension)parent.getExtension();
if (!global.isIncluded() && global.isPreferInline()) {
ComplexTypeElement type = (ComplexTypeElement)parent;
ComponentExtension typeext = (ComponentExtension)type.getExtension();
typeext.setOverrideType(derive.getBase());
if (s_logger.isDebugEnabled()) {
s_logger.debug(lead + "set substitution for global complex type " +
SchemaUtils.componentPath(type) + " to base type from derivation " +
SchemaUtils.componentPath(childcomp));
}
return true;
}
}
break;
}
case SchemaBase.ELEMENT_TYPE:
{
// set the element type to the restriction base
ElementElement elem = (ElementElement)parent;
elem.setTypeDefinition(derive.getBaseType());
if (s_logger.isDebugEnabled()) {
s_logger.debug(lead + "replaced element " + SchemaUtils.componentPath(elem) +
" type with base type from derivation " + SchemaUtils.componentPath(childcomp));
}
return true;
}
case SchemaBase.SIMPLETYPE_TYPE:
{
// replace type only if global type definition
if (parent.isGlobal()) {
GlobalExtension global = (GlobalExtension)parent.getExtension();
if (!global.isIncluded()) {
SimpleTypeElement type = (SimpleTypeElement)parent;
ComponentExtension parentext = (ComponentExtension)type.getExtension();
parentext.setOverrideType(derive.getBase());
return true;
}
}
break;
}
case SchemaBase.UNION_TYPE:
{
// this will be handled by union normalization, so just leave in place
return false;
}
}
parent = parent.getParent();
}
return false;
}
/**
* Normalize the child schema definition. This recursively traverses the schema model tree rooted in the
* component associated with this extension, normalizing each child component.
*
* TODO: handle revalidation for changed subtrees
*
* @param depth nesting depth for validation
* @return true if any part of tree under this component modified, false if not
*/
protected boolean normalize(int depth) {
// initialize debug handling
String path = null;
String lead = null;
OpenAttrBase topcomp = getComponent();
if (s_logger.isDebugEnabled()) {
path = SchemaUtils.componentPath(topcomp);
lead = SchemaUtils.getIndentation(depth);
s_logger.debug(lead + "entering normalization for node " + path);
}
// normalize each child component in turn
int count = topcomp.getChildCount();
boolean modified = false;
boolean compact = false;
for (int i = 0; i < count; i++) {
SchemaBase child = topcomp.getChild(i);
if (child instanceof OpenAttrBase) {
// start by normalizing the child component content
OpenAttrBase childcomp = (OpenAttrBase)child;
ComponentExtension childext = (ComponentExtension)childcomp.getExtension();
if (childext.normalize(depth+1)) {
modified = true;
}
// check for child components with special normalization handling
switch (childcomp.type()) {
case SchemaBase.ALL_TYPE:
case SchemaBase.CHOICE_TYPE:
case SchemaBase.SEQUENCE_TYPE:
{
// child component is a compositor, so see if it can be deleted or replaced
CommonCompositorDefinition compositor = (CommonCompositorDefinition)childcomp;
int size = compositor.getParticleList().size();
if (size == 0) {
// empty compositor, just remove (always safe to do this)
childext.setRemoved(true);
modified = true;
if (s_logger.isDebugEnabled()) {
s_logger.debug(lead + "eliminated empty compositor " + path);
}
} else if (size == 1) {
// single component in compositor, first try to convert compositor to singleton
OpenAttrBase grandchild = (OpenAttrBase)compositor.getParticleList().get(0);
IArity particle = (IArity)grandchild;
if (SchemaUtils.isRepeated(compositor)) {
if (!SchemaUtils.isRepeated(particle)) {
// repeated compositor with non-repeated particle, so pass repeat to particle
if (s_logger.isDebugEnabled()) {
s_logger.debug(lead + "passing repeat from compositor " +
SchemaUtils.componentPath(childcomp) + " to only child " +
SchemaUtils.describeComponent(grandchild));
}
particle.setMaxOccurs(compositor.getMaxOccurs());
((ComponentExtension)grandchild.getExtension()).setRepeated(true);
compositor.setMaxOccurs(null);
((ComponentExtension)compositor.getExtension()).setRepeated(false);
} else if ((compositor.getMaxOccurs().isUnbounded() &&
particle.getMaxOccurs().isUnbounded())) {
// unbounded compositor with unbounded particle, just wipe repeat from compositor
if (s_logger.isDebugEnabled()) {
s_logger.debug(lead + "clearing unbounded from compositor " +
SchemaUtils.componentPath(childcomp) + " with unbounded only child " +
SchemaUtils.describeComponent(grandchild));
}
compositor.setMaxOccurs(null);
((ComponentExtension)compositor.getExtension()).setRepeated(false);
}
}
if (SchemaUtils.isOptional(compositor)) {
if (SchemaUtils.isOptional(particle)) {
// optional compositor with optional particle, just wipe optional from compositor
if (s_logger.isDebugEnabled()) {
s_logger.debug(lead + "clearing optional from compositor " +
SchemaUtils.componentPath(childcomp) + " with optional only child " +
SchemaUtils.describeComponent(grandchild));
}
compositor.setMinOccurs(null);
((ComponentExtension)compositor.getExtension()).setOptional(false);
} else if (Count.isCountEqual(1, particle.getMinOccurs())) {
// optional compositor with required particle, so pass optional to particle
if (s_logger.isDebugEnabled()) {
s_logger.debug(lead + "passing optional from compositor " +
SchemaUtils.componentPath(childcomp) + " to required only child " +
SchemaUtils.describeComponent(grandchild));
}
particle.setMinOccurs(Count.COUNT_ZERO);
((ComponentExtension)grandchild.getExtension()).setOptional(true);
compositor.setMinOccurs(null);
((ComponentExtension)compositor.getExtension()).setOptional(false);
}
}
// check if top component is also a compositor
if (topcomp instanceof CommonCompositorDefinition) {
// nested compositor, check if can be simplified
if (SchemaUtils.isSingleton(compositor)) {
// nested singleton compositor with only child, just replace with the child
topcomp.replaceChild(i, grandchild);
modified = true;
if (s_logger.isDebugEnabled()) {
s_logger.debug(lead + "replacing singleton compositor " +
SchemaUtils.componentPath(childcomp) + " with only child " +
SchemaUtils.describeComponent(grandchild));
}
} else if (compositor instanceof ChoiceElement) {
// replace choice with sequence to simplify handling, since just one particle
if (s_logger.isDebugEnabled()) {
s_logger.debug(lead + "substituting sequence for choice " +
SchemaUtils.componentPath(childcomp) + " with only one child");
}
SequenceElement sequence = new SequenceElement();
sequence.setAnnotation(compositor.getAnnotation());
sequence.setExtension(compositor.getExtension());
sequence.setMaxOccurs(compositor.getMaxOccurs());
sequence.setMinOccurs(compositor.getMinOccurs());
sequence.getParticleList().add(grandchild);
topcomp.replaceChild(i, sequence);
modified = true;
}
}
}
break;
}
case SchemaBase.EXTENSION_TYPE:
{
if (childcomp instanceof SimpleExtensionElement) {
// replace empty simple type extension with base type
SimpleExtensionElement extend = (SimpleExtensionElement)childcomp;
if (extend.getAttributeList().size() == 0 && extend.getAnyAttribute() == null) {
modified = substituteTypeDerivation(lead, topcomp, childcomp, extend);
}
} else {
// replace empty complex type extension with base type
ComplexExtensionElement extend = (ComplexExtensionElement)child;
if (extend.getContentDefinition() == null && extend.getAttributeList().size() == 0 &&
extend.getAnyAttribute() == null) {
modified = substituteTypeDerivation(lead, topcomp, childcomp, extend);
}
}
break;
}
case SchemaBase.RESTRICTION_TYPE:
{
if (childcomp instanceof SimpleRestrictionElement) {
// replace simple type restriction with base type unless it has facets
SimpleRestrictionElement restrict = (SimpleRestrictionElement)childcomp;
if (restrict.getFacetsList().size() == 0 && restrict.getBase() != null) {
QName base = restrict.getBase();
if (base == null) {
// derivation using inline base type, just eliminate the restriction
} else {
modified = substituteTypeDerivation(lead, topcomp, childcomp, restrict);
}
}
} else {
// always replace complex type restriction with base type
ComplexRestrictionElement restrict = (ComplexRestrictionElement)child;
modified = substituteTypeDerivation(lead, topcomp, childcomp, restrict);
}
break;
}
}
// delete child component if flagged for removal
if (childext.isRemoved()) {
removeChild(i);
compact = true;
}
}
}
if (compact) {
topcomp.compactChildren();
modified = true;
}
// handle union normalization after all children have been normalized
if (topcomp.type() == SchemaBase.UNION_TYPE) {
// start by checking duplicates in the member types
compact = false;
UnionElement union = (UnionElement)topcomp;
Set typeset = new HashSet();
ArrayList keeptypes = new ArrayList();
QName[] membertypes = union.getMemberTypes();
if (membertypes != null) {
for (int i = 0; i < membertypes.length; i++) {
QName type = membertypes[i];
if (typeset.contains(type)) {
if (s_logger.isDebugEnabled()) {
s_logger.debug(lead + "removed redundant member type " + type + " from " + path);
}
} else {
typeset.add(type);
keeptypes.add(type);
}
}
}
// then check inline types for duplicates, simplifying where possible
count = union.getChildCount();
for (int i = 0; i < count; i++) {
SchemaBase child = topcomp.getChild(i);
if (child instanceof OpenAttrBase) {
// child schema component must be an inline simple type definition
SimpleTypeElement simple = (SimpleTypeElement)child;
boolean keeper = false;
SchemaBase derivation = simple.getDerivation();
QName repltype = null;
if (derivation != null) {
// keep the inline definition by default, but check for replacement cases
keeper = true;
if (derivation.type() == SchemaBase.RESTRICTION_TYPE) {
SimpleRestrictionElement innerrestrict = (SimpleRestrictionElement)derivation;
if (innerrestrict.getChildCount() == 0) {
// treat empty restriction the same as a member type from list
repltype = innerrestrict.getBase();
if (typeset.contains(repltype)) {
keeper = false;
}
}
} else if (derivation.type() == SchemaBase.UNION_TYPE) {
UnionElement innerunion = (UnionElement)derivation;
QName[] innertypes = innerunion.getMemberTypes();
FilteredSegmentList innerinlines = innerunion.getInlineBaseList();
if (innertypes.length + innerinlines.size() == 1) {
// replace child union with single type from union
if (innertypes.length == 1) {
// global type reference, delete the child union and check if new type
repltype = innertypes[0];
if (typeset.contains(repltype)) {
keeper = false;
}
} else {
// inline type definition, replace the child union with the inline type
union.replaceChild(i, (SchemaBase)innerinlines.get(0));
}
}
}
}
if (keeper) {
if (repltype != null) {
// convert unnecessary inline type to member type
typeset.add(repltype);
removeChild(i);
compact = true;
if (s_logger.isDebugEnabled()) {
s_logger.debug(lead + "converted inline type " + SchemaUtils.describeComponent(topcomp) +
" to member type in " + path);
}
}
} else {
// remove inline definition that matches already-processed type
removeChild(i);
compact = true;
if (s_logger.isDebugEnabled()) {
s_logger.debug(lead + "removed redundant inline type from " + path);
}
}
}
}
// set the new list of member types for union
QName[] newtypes = null;
if (keeptypes.size() > 0) {
newtypes = (QName[])keeptypes.toArray(new QName[keeptypes.size()]);
}
union.setMemberTypes(newtypes);
// clean up for any deleted child components
if (compact) {
topcomp.compactChildren();
modified = true;
}
}
if (s_logger.isDebugEnabled()) {
s_logger.debug(lead + "exiting normalization for node " + path + " with modified " + modified);
}
return modified;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/custom/SchemaCustom.java 0000644 0001750 0001750 00000053141 11424512022 027260 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.custom;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.apache.log4j.Logger;
import org.jibx.binding.util.ObjectStack;
import org.jibx.custom.CustomUtils;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.schema.INamed;
import org.jibx.schema.SchemaContextTracker;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.SchemaVisitor;
import org.jibx.schema.TreeWalker;
import org.jibx.schema.codegen.PackageHolder;
import org.jibx.schema.elements.AnnotatedBase;
import org.jibx.schema.elements.FacetElement;
import org.jibx.schema.elements.OpenAttrBase;
import org.jibx.schema.elements.SchemaBase;
import org.jibx.schema.elements.SchemaElement;
import org.jibx.schema.elements.SchemaPath;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Individual schema customization information.
*
* @author Dennis M. Sosnoski
*/
public class SchemaCustom extends SchemaRootBase
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(SchemaCustom.class.getName());
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "excludes", "force-types", "includes", "name", "namespace" },
SchemaRootBase.s_allowedAttributes);
//
// Bound instance data
/** Schema name. */
private String m_name;
/** Schema namespace. */
private String m_namespace;
/** Always specify property types flag. */
private boolean m_forceTypes;
/** Global names included in code generation. */
private String[] m_includes;
/** Global names excluded from code generation. */
private String[] m_excludes;
//
// Internal instance data
/** Schema definition. */
private SchemaElement m_schema;
/** Extension attached to actual schema element (only used for children). */
private SchemaExtension m_extension;
/**
* Constructor.
*
* @param parent
*/
public SchemaCustom(SchemasetCustom parent) {
super(parent);
}
/**
* Constructor for constructing instance directly.
*
* @param parent
* @param name schema name
* @param namespace target namespace URI
* @param includes definition names to be included in generation
* @param excludes definition names to be excluded from generation
*/
public SchemaCustom(SchemasetCustom parent, String name, String namespace, String[] includes, String[] excludes) {
this(parent);
m_name = name;
m_namespace = namespace;
m_includes = includes;
m_excludes = excludes;
}
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
*/
private void preSet(IUnmarshallingContext uctx) {
validateAttributes(uctx, s_allowedAttributes);
}
/**
* Get the names of definitions to be included in generation.
*
* @return names
*/
public String[] getIncludes() {
return m_includes;
}
/**
* Set the names of definitions to be included in generation. This only has any effect on the code generation if
* called before {@link #extend(PackageHolder, ValidationContext)} is called.
*
* @param includes
*/
public void setIncludes(String[] includes) {
m_includes = includes;
}
/**
* Get the names of definitions to be excluded from generation.
*
* @return names
*/
public String[] getExcludes() {
return m_includes;
}
/**
* Set the names of definitions to be excluded from generation. This only has any effect on the code generation if
* called before {@link #extend(PackageHolder, ValidationContext)} is called.
*
* @param excludes
*/
public void setExcludes(String[] excludes) {
m_excludes = excludes;
}
/**
* Get schema name.
*
* @return name
*/
public String getName() {
return m_name;
}
/**
* Set schema name.
*
* @param name
*/
public void setName(String name) {
m_name = name;
}
/**
* Get schema namespace.
*
* @return namespace
*/
public String getNamespace() {
return m_namespace;
}
/**
* Set schema namespace.
*
* @param namespace
*/
public void setNamespace(String namespace) {
m_namespace = namespace;
}
/**
* Check if type specifications forced for schema.
*
* @return true if types forced, false if not
*/
public boolean isForceTypes() {
return m_forceTypes;
}
/**
* Set type specifications forced for schema.
*
* @param force true if types forced, false if not
*/
public void setForceTypes(Boolean force) {
m_forceTypes = force.booleanValue();
}
/**
* Get schema definition.
*
* @return schema
*/
public SchemaElement getSchema() {
return m_schema;
}
/**
* Set schema definition.
*
* @param name
* @param schema
*/
public void setSchema(String name, SchemaElement schema) {
if (m_name == null) {
m_name = name;
}
if (m_namespace == null) {
m_namespace = schema.getEffectiveNamespace();
}
m_schema = schema;
}
/**
* Check if this customization matches a particular schema.
*
* @param name
* @param schema
* @return true if a match, false if not
*/
public boolean checkMatch(String name, SchemaElement schema) {
return (m_name == null || (m_name.equals(name)))
&& (m_namespace == null || (m_namespace.equals(schema.getEffectiveNamespace())));
}
/**
* Build the extensions tree for a global definition.
*
* @param visitor
* @param wlkr
* @param anno
*/
private void extendGlobal(ExtensionBuilderVisitor visitor, TreeWalker wlkr, GlobalExtension anno) {
visitor.setRoot(anno);
wlkr.walkChildren(anno.getComponent(), visitor);
}
/**
* Strip the annotation components (at any level) from a schema definitions.
*/
public void stripAnnotations() {
// first delete all annotation children of the schema element itself
TreeWalker wlkr = new TreeWalker(null, new SchemaContextTracker());
for (int i = 0; i < m_schema.getChildCount(); i++) {
if (m_schema.getChild(i).type() == SchemaBase.ANNOTATION_TYPE) {
m_schema.detachChild(i);
}
}
m_schema.compactChildren();
// now remove all embedded annotations within any definitions
wlkr.walkSchema(m_schema, new AnnotationDeletionVisitor());
}
/**
* Evaluate the remaining path for a customization after the first step, and apply it to the extension for each
* matching schema component. If no matches are found or multiple matches are found this generates a warning.
*
* @param path customization path
* @param match starting point for path
* @param custom customization information
* @param vctx validation context
*/
private static void applyRemainingCustomizationPath(SchemaPath path, OpenAttrBase match, ComponentCustom custom,
ValidationContext vctx) {
List matches = path.partialMatchMultiple(1, path.getPathLength()-1, match);
if (matches.size() == 0) {
vctx.addWarning("No matches found for customization expression", custom);
} else {
if (matches.size() > 1) {
vctx.addWarning("Found " + matches.size() + " matches for customization expression", custom);
}
for (Iterator iter = matches.iterator(); iter.hasNext();) {
OpenAttrBase target = (OpenAttrBase)iter.next();
custom.apply((ComponentExtension)target.getExtension(), vctx);
}
}
}
/**
* Build the schema extension structure. This first builds extensions for all the global definitions in the schema,
* marking the ones specified to be included or excluded from the schema, and for all the child components of the
* non-excluded globals. It then applies the customizations to the extensions.
*
* @param pack package for generated classes (null if no code generation)
* @param vctx validation context
*/
public void extend(PackageHolder pack, ValidationContext vctx) {
// build the basic include and exclude sets
Set inclset = Collections.EMPTY_SET;
Set exclset = Collections.EMPTY_SET;
if (m_includes != null) {
inclset = CustomUtils.nameSet(m_includes);
}
if (m_excludes != null) {
exclset = CustomUtils.nameSet(m_excludes);
}
// check for any conflicts between the two
if (!inclset.isEmpty() && !exclset.isEmpty()) {
for (Iterator iter = inclset.iterator(); iter.hasNext();) {
Object next = iter.next();
if (exclset.contains(next)) {
vctx.addError("Name '" + next.toString() + "' cannot be on both include and exclude list", this);
}
}
}
// build the extensions for each global definition component (and descendant components)
m_extension = new SchemaExtension(m_schema, this, pack);
List globals = m_schema.getTopLevelChildren();
ExtensionBuilderVisitor builder = new ExtensionBuilderVisitor();
// Level level = TreeWalker.setLogging(s_logger.getLevel());
Set foundset = Collections.EMPTY_SET;
if (m_includes != null || m_excludes != null) {
foundset = new HashSet();
}
TreeWalker wlkr = new TreeWalker(null, new SchemaContextTracker());
for (Iterator iter = globals.iterator(); iter.hasNext();) {
OpenAttrBase global = (OpenAttrBase)iter.next();
if (global instanceof INamed) {
// set up the basic global definition extension
GlobalExtension exten = new GlobalExtension(m_extension, global);
String name = ((INamed)global).getName();
boolean exclude = exclset.contains(name);
exten.setRemoved(exclude);
if (exclude) {
foundset.add(name);
}
boolean include = inclset.contains(name);
exten.setIncluded(include);
if (include) {
foundset.add(name);
}
// initialize extensions for full tree of non-excluded global definition components
if (!exten.isRemoved()) {
extendGlobal(builder, wlkr, exten);
} else if (global.type() == SchemaBase.SIMPLETYPE_TYPE ||
global.type() == SchemaBase.COMPLEXTYPE_TYPE) {
setReplacement(((INamed)global).getQName(), null);
}
}
}
// TreeWalker.setLogging(level);
// report any names not found
if (foundset.size() < exclset.size() + inclset.size()) {
Set mergeset = new HashSet();
mergeset.addAll(exclset);
mergeset.addAll(inclset);
for (Iterator iterator = mergeset.iterator(); iterator.hasNext();) {
String name = (String)iterator.next();
if (!foundset.contains(name)) {
vctx.addWarning("Name '" + name + "' not found in schema", this);
}
}
}
// use child customizations to amend the generated extensions
int size = getChildren().size();
for (int i = 0; i < size; i++) {
ComponentCustom custom = (ComponentCustom)getChildren().get(i);
SchemaPath path = custom.buildPath(vctx);
if (path != null) {
if (path.isWildStart()) {
vctx.addError("Top level customizations cannot use wildcard as first step", custom);
} else {
// match only the first path step
OpenAttrBase match = path.partialMatchUnique(0, 0, m_schema);
if (s_logger.isDebugEnabled()) {
if (match == null) {
s_logger.debug("No global schema component found for customization " + custom);
} else {
s_logger.debug("Matched customization " + custom + " to global schema component "
+ SchemaUtils.describeComponent(match));
}
}
if (match != null) {
String name = ((INamed)match).getName();
GlobalExtension exten = (GlobalExtension)match.getExtension();
if (custom.isExcluded()) {
// check if customization applies to descendant of global definition component
if (path.getPathLength() == 1) {
// force exclude if generation skipped by customization
if (exten.isIncluded()) {
vctx.addWarning("Name '" + name
+ "' is on include list for schema, but excluded by customization", custom);
}
exten.setIncluded(false);
exten.setRemoved(true);
} else {
// apply customization to target component extension(s)
applyRemainingCustomizationPath(path, match, custom, vctx);
}
} else {
// check for customization for global excluded at schema level
if (exten.isRemoved()) {
vctx.addWarning("Name '" + name
+ "' is on excludes list for schema, but has a customization", custom);
exten.setRemoved(false);
extendGlobal(builder, wlkr, exten);
}
// check if customization applies to descendant of global definition component
if (path.getPathLength() > 1) {
applyRemainingCustomizationPath(path, match, custom, vctx);
} else {
custom.apply((ComponentExtension)match.getExtension(), vctx);
}
}
}
}
}
}
// flag extensions for facets to be removed from schema
SchemaVisitor visitor = new FacetRemoverVisitor(this);
for (Iterator iter = globals.iterator(); iter.hasNext();) {
OpenAttrBase global = (OpenAttrBase)iter.next();
ComponentExtension exten = (ComponentExtension)global.getExtension();
if (exten != null && !exten.isRemoved()) {
wlkr.walkElement(global, visitor);
}
}
}
/**
* Factory used during unmarshalling.
*
* @param ictx
* @return instance
*/
private static SchemaCustom factory(IUnmarshallingContext ictx) {
return new SchemaCustom((SchemasetCustom)getContainingObject(ictx));
}
/**
* Visitor to delete annotations from schema components.
*/
private static class AnnotationDeletionVisitor extends SchemaVisitor
{
/**
* Visit any component of schema definition. This just deletes any annotation present.
*
* @param node
* @return true to continue expansion
*/
public boolean visit(AnnotatedBase node) {
node.setAnnotation(null);
return true;
}
}
/**
* Visitor to build basic extensions for schema components. This also sets class and base names for the extensions,
* if the component has a name.
*/
private static class ExtensionBuilderVisitor extends SchemaVisitor
{
/** Extension for root component being expanded. */
private GlobalExtension m_root;
/**
* Set the extension for the root of the schema definition component to be expanded.
*
* @param root
*/
public void setRoot(GlobalExtension root) {
m_root = root;
}
/**
* Visit any component of schema definition. This just creates the extension for the component.
*
* @param node
* @return true to continue expansion
*/
public boolean visit(AnnotatedBase node) {
node.setExtension(new ComponentExtension(node, m_root));
return true;
}
}
/**
* Visitor to flag extensions to remove unused facets. This relies on each customization being set as the type
* substitution handler for the corresponding extension.
*/
private static class FacetRemoverVisitor extends SchemaVisitor
{
/** Stack of active customizations. */
private ObjectStack m_customStack;
/** Currently active customization. */
private NestingCustomBase m_currentCustom;
/**
* Constructor.
*
* @param root customization for root element being processed
*/
public FacetRemoverVisitor(SchemaCustom root) {
m_customStack = new ObjectStack();
m_currentCustom = root;
}
/**
* Exit the generic precursor class of all elements which can have customizations. This just pops the saved
* customization for the higher level off the stack.
*
* @param node
*/
public void exit(AnnotatedBase node) {
super.exit(node);
m_currentCustom = (NestingCustomBase)m_customStack.pop();
}
/**
* Visit a facet element. This first calls the handling for the supertype, in order to activate a customization
* that applies to this particular element, then checks if the facet element subtype is to be included in the
* code generation.
*
* @param node
* @return true if continuing expansion, false if not
*/
public boolean visit(FacetElement node) {
boolean ret = super.visit(node);
if ((m_currentCustom.getActiveFacetsMask() & node.bit()) == 0) {
((ComponentExtension)node.getExtension()).setRemoved(true);
}
return ret;
}
/**
* Visit the generic precursor class of all elements which can have customizations. This saves the current
* customization on the stack, then checks for one associated with the current element and makes that active if
* found.
*
* @param node
* @return true if continuing expansion, false if not
*/
public boolean visit(AnnotatedBase node) {
m_customStack.push(m_currentCustom);
NestingCustomBase custom = (NestingCustomBase)(((ComponentExtension)node.getExtension())).getCustom();
if (custom != null) {
m_currentCustom = custom;
}
return super.visit(node);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/custom/TypeReplacer.java 0000644 0001750 0001750 00000003573 10673717104 027305 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.custom;
import org.jibx.runtime.QName;
/**
* Interface defining type substitutions.
*
* @author Dennis M. Sosnoski
*/
public interface TypeReplacer
{
/**
* Get replacement type.
*
* @param qname
* @return replacement type (the same as the supplied type, if no replacement defined)
*/
QName getReplacement(QName qname);
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/custom/BaseExtension.java 0000644 0001750 0001750 00000010171 11057606542 027445 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.custom;
import org.apache.log4j.Logger;
import org.jibx.runtime.QName;
import org.jibx.schema.elements.OpenAttrBase;
/**
* Base extension information for any schema component. This is the basic extension structure that applies to each
* schema component.
*
* @author Dennis M. Sosnoski
*/
public abstract class BaseExtension
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(BaseExtension.class.getName());
//
// Arity types
public static final int ARITY_OPTIONAL_SINGLETON = 0;
public static final int ARITY_REQUIRED_SINGLETON = 1;
public static final int ARITY_OPTIONAL_COLLECTION = 2;
public static final int ARITY_REQUIRED_COLLECTION = 3;
//
// Instance data
/** Annotated schema definition component. */
private final OpenAttrBase m_component;
/** Type replacement implementation (null if no replacements at this level). */
private TypeReplacer m_typeReplacer;
/**
* Constructor.
*
* @param comp
*/
public BaseExtension(OpenAttrBase comp) {
m_component = comp;
comp.setExtension(this);
}
/**
* Get schema component.
*
* @return component
*/
public OpenAttrBase getComponent() {
return m_component;
}
/**
* Set type replacer. This type replacer will apply to this extension and any child extensions which do not have
* their own type replacers.
*
* @param replacer
*/
public void setTypeReplacer(TypeReplacer replacer) {
m_typeReplacer = replacer;
}
/**
* Get the replacement type to be substituted for a supplied type. This starts with this extension and then scans
* up the tree to find the first extension with a type replacer defined. If a type replacer is found at any level
* it is applied to the supplied type. If multiple extensions in the path up the tree have type replacers defined,
* only the first type replacer is used.
*
* @param qname original type
* @return substitute type (null if deletion; original type, if no substitution defined)
*/
public QName getReplacementType(QName qname) {
// use direct navigation up tree to avoid call overhead
BaseExtension ancestor = this;
while (ancestor != null) {
if (ancestor.m_typeReplacer != null) {
return ancestor.m_typeReplacer.getReplacement(qname);
}
ancestor = (BaseExtension)ancestor.getComponent().getParent().getExtension();
}
return qname;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/custom/GeneratorCustom.java 0000644 0001750 0001750 00000006520 11124146622 030013 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.custom;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.util.StringArray;
/**
* Generator customization.
*
* TODO: use separate subclasses for the different types of generation, or an interface? looks like there'll only be a
* few alternatives (normal class, enumeration, collection). or have generators for different types of fields, and such?
* that gives the maximum flexibility, but also adds a lot of complexity. at a minimum, need to support different types
* of generators for enumeration, choice, union, and collection value types. would also like to support different
* validation method generators, orthogonal to the other variations. finally, want to support different JavaDoc
* formatters. perhaps best to use a separate class for each.
*
* @author Dennis M. Sosnoski
*/
public class GeneratorCustom extends CustomBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes = new StringArray(new String[] { "class" });
/** Generator class name. */
private String m_class;
/** Parameter values for generator class instance. */
private String[] m_parameters;
/**
* Constructor.
*
* @param parent
*/
public GeneratorCustom(NestingCustomBase parent) {
super(parent);
}
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
*/
private void preSet(IUnmarshallingContext uctx) {
validateAttributes(uctx, s_allowedAttributes);
}
/**
* Get class name.
*
* @return class
*/
public String getClassName() {
return m_class;
}
/**
* Get parameter values.
*
* @return parameters
*/
public String[] getParameters() {
return m_parameters;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/Refactory.java 0000644 0001750 0001750 00000106635 11257647464 025347 0 ustar twerner twerner /*
* Copyright (c) 2008-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.Writer;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.jibx.binding.model.BindingOrganizer;
import org.jibx.extras.DocumentComparator;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.schema.INamed;
import org.jibx.schema.ISchemaResolver;
import org.jibx.schema.SchemaContextTracker;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.SchemaVisitor;
import org.jibx.schema.TreeWalker;
import org.jibx.schema.UrlResolver;
import org.jibx.schema.codegen.custom.ComponentExtension;
import org.jibx.schema.codegen.custom.GlobalExtension;
import org.jibx.schema.codegen.custom.SchemaCustom;
import org.jibx.schema.codegen.custom.SchemasetCustom;
import org.jibx.schema.elements.FilteredSegmentList;
import org.jibx.schema.elements.OpenAttrBase;
import org.jibx.schema.elements.SchemaBase;
import org.jibx.schema.elements.SchemaElement;
import org.jibx.schema.elements.SchemaLocationBase;
import org.jibx.schema.elements.SimpleRestrictionElement;
import org.jibx.schema.elements.UnionElement;
import org.jibx.schema.support.SchemaTypes;
import org.jibx.schema.validation.NameMergeVisitor;
import org.jibx.schema.validation.PrevalidationVisitor;
import org.jibx.schema.validation.NameRegistrationVisitor;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.schema.validation.ValidationProblem;
import org.jibx.schema.validation.ValidationVisitor;
import org.jibx.util.InsertionOrderedSet;
import org.jibx.util.LazyList;
import org.jibx.util.NameUtilities;
import org.xmlpull.v1.XmlPullParserException;
/**
* Schema refactoring tool. Although many of the methods in this class use public access, they are intended
* for use only by the JiBX developers and may change from one release to the next. To make use of this class from your
* own code, call the {@link #main(String[])} method with an appropriate argument list.
*
* @author Dennis M. Sosnoski
*/
public class Refactory
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(Refactory.class.getName());
/** Default type replacements applied. */
private static final QName[] DEFAULT_REPLACEMENTS =
new QName[] {
SchemaTypes.ANY_URI.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.DURATION.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.ENTITIES.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.ENTITY.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.GDAY.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.GMONTH.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.GMONTHDAY.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.GYEAR.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.GYEARMONTH.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.ID.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.IDREF.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.IDREFS.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.LANGUAGE.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.NAME.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.NEGATIVE_INTEGER.getQName(), SchemaTypes.INTEGER.getQName(),
SchemaTypes.NON_NEGATIVE_INTEGER.getQName(), SchemaTypes.INTEGER.getQName(),
SchemaTypes.NON_POSITIVE_INTEGER.getQName(), SchemaTypes.INTEGER.getQName(),
SchemaTypes.NORMALIZED_STRING.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.NCNAME.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.NMTOKEN.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.NMTOKENS.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.NOTATION.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.POSITIVE_INTEGER.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.TOKEN.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.UNSIGNED_BYTE.getQName(), SchemaTypes.BYTE.getQName(),
SchemaTypes.UNSIGNED_INT.getQName(), SchemaTypes.INT.getQName(),
SchemaTypes.UNSIGNED_LONG.getQName(), SchemaTypes.LONG.getQName(),
SchemaTypes.UNSIGNED_SHORT.getQName(), SchemaTypes.SHORT.getQName()
};
/** Mask for schema elements which derive from a type. */
private static final long TYPE_DERIVE_MASK =
SchemaBase.ELEMENT_MASKS[SchemaBase.EXTENSION_TYPE] | SchemaBase.ELEMENT_MASKS[SchemaBase.RESTRICTION_TYPE];
/** Mask for schema elements which define a type. */
private static final long TYPE_DEFINE_MASK =
SchemaBase.ELEMENT_MASKS[SchemaBase.COMPLEXTYPE_TYPE] | SchemaBase.ELEMENT_MASKS[SchemaBase.SIMPLETYPE_TYPE];
/** Mask for schema elements which block name inheritance downward. */
private static final long BLOCK_NAME_INHERIT_MASK =
TYPE_DERIVE_MASK | SchemaBase.ELEMENT_MASKS[SchemaBase.UNION_TYPE];
/** Code generation customizations. */
private final SchemasetCustom m_global;
/** Root URL for schemas. */
private final URL m_schemaRoot;
/** Root directory for schemas. */
private final File m_schemaDir;
/** Target directory for code generation. */
private final File m_targetDir;
/** Context for loading and processing schemas. */
private final ValidationContext m_validationContext;
/** Definitions to be generated (may be global schema definitions, or reused nested components with classes). */
private ArrayList m_definitions;
/** Directory for constructed bindings. */
private BindingOrganizer m_bindingDirectory;
/**
* Constructor.
*
* @param parms command line parameters
*/
public Refactory(RefactoryCommandLine parms) {
m_global = parms.getCustomRoot();
m_global.setSubstitutions(DEFAULT_REPLACEMENTS);
m_schemaRoot = parms.getSchemaRoot();
m_schemaDir = parms.getSchemaDir();
m_targetDir = parms.getGeneratePath();
m_validationContext = new ValidationContext();
}
/**
* Constructor used by tests. This uses supplied schemas and skips writing to the file system.
*
* @param custom
* @param vctx
*/
public Refactory(SchemasetCustom custom, ValidationContext vctx) {
m_global = custom;
m_global.setSubstitutions(DEFAULT_REPLACEMENTS);
m_schemaRoot = null;
m_schemaDir = null;
m_targetDir = null;
m_validationContext = vctx;
}
/**
* Find the most specific schemaset owning a schema. If multiple matches are found which are not in line of
* containment the first match is returned and the conflict is reported as an error.
*
* @param schema
* @param custom schema set customization
* @return owning schemaset, null if none
*/
private SchemasetCustom findSchemaset(SchemaElement schema, SchemasetCustom custom) {
LazyList childs = custom.getChildren();
SchemasetCustom owner = null;
String name = schema.getResolver().getName();
for (int i = 0; i < childs.size(); i++) {
Object child = childs.get(i);
if (child instanceof SchemasetCustom) {
SchemasetCustom schemaset = (SchemasetCustom)child;
if (schemaset.isInSet(name, schema)) {
SchemasetCustom match = findSchemaset(schema, schemaset);
if (match != null) {
if (owner == null) {
owner = match;
} else {
m_validationContext.addError("schema-set overlap on schema " + name + " (first match "
+ ValidationProblem.componentDescription(owner) + ')', match);
}
}
}
}
}
return owner == null ? custom : owner;
}
/**
* Validate the schemas.
*
* @param schemas schemas to be validated
*/
public void validateSchemas(SchemaElement[] schemas) {
// validate the schemas and report any problems
TreeWalker wlkr = new TreeWalker(m_validationContext, m_validationContext);
s_logger.debug("Beginning schema prevalidation pass");
m_validationContext.clearTraversed();
s_logger.debug("Beginning schema prevalidation pass");
for (int i = 0; i < schemas.length; i++) {
wlkr.walkSchema(schemas[i], new PrevalidationVisitor(m_validationContext));
s_logger.debug("After prevalidation schema " + schemas[i].getResolver().getName() +
" has effective namespace " + schemas[i].getEffectiveNamespace());
}
s_logger.debug("Beginning name registration pass");
m_validationContext.clearTraversed();
for (int i = 0; i < schemas.length; i++) {
wlkr.walkSchema(schemas[i], new NameRegistrationVisitor(m_validationContext));
}
s_logger.debug("Beginning name merge pass");
m_validationContext.clearTraversed();
for (int i = 0; i < schemas.length; i++) {
wlkr.walkSchema(schemas[i], new NameMergeVisitor(m_validationContext));
}
s_logger.debug("Beginning validation pass");
m_validationContext.clearTraversed();
for (int i = 0; i < schemas.length; i++) {
wlkr.walkSchema(schemas[i], new ValidationVisitor(m_validationContext));
s_logger.debug("After validation schema " + schemas[i].getResolver().getName() +
" has effective namespace " + schemas[i].getEffectiveNamespace());
}
}
/**
* Load and validate the root schema list.
*
* @param list resolvers for schemas to be loaded
* @return schemas in validation order
* @throws JiBXException on unrecoverable error in schemas
* @throws IOException on error reading schemas
*/
private SchemaElement[] load(List list) throws JiBXException, IOException {
IBindingFactory factory = BindingDirectory.getFactory(SchemaUtils.XS_PREFIX_BINDING, SchemaElement.class);
IUnmarshallingContext ictx = factory.createUnmarshallingContext();
int count = list.size();
SchemaElement[] schemas = new SchemaElement[count];
int fill = 0;
for (Iterator iter = list.iterator(); iter.hasNext();) {
// unmarshal document to construct schema structure
UrlResolver resolver = (UrlResolver)iter.next();
ictx.setDocument(resolver.getContent(), resolver.getName(), null);
ictx.setUserContext(m_validationContext);
Object obj = ictx.unmarshalElement();
// set resolver for use during schema processing
SchemaElement schema = (SchemaElement)obj;
schemas[fill++] = schema;
schema.setResolver(resolver);
String id = resolver.getId();
m_validationContext.setSchema(id, schema);
// verify schema roundtripping if debug enabled
if (s_logger.isDebugEnabled()) {
try {
// determine encoding of input document
String enc = ((UnmarshallingContext)ictx).getInputEncoding();
if (enc == null) {
enc = "UTF-8";
}
// marshal root object back out to document in memory
IMarshallingContext mctx = factory.createMarshallingContext();
ByteArrayOutputStream bos = new ByteArrayOutputStream();
mctx.setIndent(2);
mctx.marshalDocument(obj, "UTF-8", null, bos);
// compare with original input document
InputStreamReader brdr =
new InputStreamReader(new ByteArrayInputStream(bos.toByteArray()), "UTF-8");
InputStreamReader frdr = new InputStreamReader(resolver.getContent(), enc);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
PrintStream pstream = new PrintStream(baos);
DocumentComparator comp = new DocumentComparator(pstream);
if (comp.compare(frdr, brdr)) {
// report schema roundtripped successfully
s_logger.debug("Successfully roundtripped schema " + id);
} else {
// report problems in roundtripping schema
s_logger.debug("Errors in roundtripping schema " + id);
pstream.flush();
s_logger.debug(baos.toString());
}
} catch (XmlPullParserException e) {
s_logger.debug("Error during schema roundtripping", e);
}
}
}
// to correctly handle namespaces for includes, process namespaced schemas first
Set schemaset = new HashSet(count);
ArrayList ordereds = new ArrayList();
m_validationContext.clearTraversed();
for (int i = 0; i < count; i++) {
SchemaElement schema = schemas[i];
if (schema.getTargetNamespace() != null) {
// add namespaced schema to both reached set and processing order list
ordereds.add(schema);
schemaset.add(schema);
// add any child include and imports only to reached set
FilteredSegmentList childs = schema.getSchemaChildren();
for (int j = 0; j < childs.size(); j++) {
Object child = childs.get(j);
if (child instanceof SchemaLocationBase) {
schemaset.add(((SchemaLocationBase)child).getReferencedSchema());
}
}
}
}
// add any schemas not already covered
for (int i = 0; i < count; i++) {
SchemaElement schema = schemas[i];
if (!schemaset.contains(schema)) {
ordereds.add(schema);
}
}
// validate the schemas in order
SchemaElement[] ordschemas = (SchemaElement[])ordereds.toArray(new SchemaElement[ordereds.size()]);
validateSchemas(ordschemas);
return ordschemas;
}
/**
* Validate and apply customizations to loaded schemas.
*
* @return true if successful, false if error
*/
public boolean customizeSchemas() {
// TODO: remove this once union handling fully implemented
SchemaVisitor visitor = new SchemaVisitor() {
public void exit(UnionElement node) {
OpenAttrBase parent = node.getParent();
int count = parent.getChildCount();
for (int i = 0; i < count; i++) {
if (parent.getChild(i) == node) {
SimpleRestrictionElement empty = new SimpleRestrictionElement();
empty.setBase(SchemaTypes.STRING.getQName());
parent.replaceChild(i, empty);
break;
}
}
}
};
TreeWalker wlkr = new TreeWalker(null, new SchemaContextTracker());
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
wlkr.walkElement((SchemaElement)iter.next(), visitor);
}
// validate the customizations
m_global.validate(m_validationContext);
// create the package directory, using default package from root schemaset
String dfltpack = m_global.getPackage();
if (dfltpack == null) {
dfltpack = "";
}
// link each schema to a customization, creating a default customization if necessary
int count = 0;
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
ISchemaResolver resolver = schema.getResolver();
s_logger.debug("Assigning customization for schema " + ++count + ": " + resolver.getName());
SchemasetCustom owner = findSchemaset(schema, m_global);
SchemaCustom custom = owner.forceCustomization(resolver.getName(), resolver.getId(), schema,
m_validationContext);
custom.validate(m_validationContext);
custom.extend(null, m_validationContext);
}
// check all the customizations
m_global.checkSchemas(m_validationContext);
return !reportProblems(m_validationContext);
}
/**
* Process substitutions and deletions defined by extensions. This builds the cross-reference information for the
* global definition components of the schemas while removing references to deleted components.
*
* @return true if any changes to the schemas, false if not
*/
private boolean processExtensions() {
// first clear all the cross reference information
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
int count = schema.getChildCount();
for (int i = 0; i < count; i++) {
SchemaBase child = schema.getChild(i);
Object obj = child.getExtension();
if (obj instanceof GlobalExtension) {
((GlobalExtension)obj).resetDependencies();
}
}
}
// process each loaded schema for deletions and cross referencing
int index = 0;
m_validationContext.clearTraversed();
boolean modified = false;
// Level level = TreeWalker.setLogging(s_logger.getLevel());
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
m_validationContext.enterSchema(schema);
s_logger.debug("Applying extensions to schema " + ++index + ": " + schema.getResolver().getName());
int count = schema.getChildCount();
boolean instmod = false;
for (int i = 0; i < count; i++) {
SchemaBase child = schema.getChild(i);
Object obj = child.getExtension();
if (obj instanceof GlobalExtension) {
// apply extension to global definition element
ComponentExtension exten = (ComponentExtension)obj;
if (exten.isRemoved()) {
// just eliminate this definition from the schema
schema.detachChild(i);
instmod = true;
} else {
// process the definition to remove references to deleted components
exten.applyAndCountUsage(m_validationContext);
}
}
}
if (instmod) {
schema.compactChildren();
modified = true;
}
m_validationContext.exitSchema();
}
// TreeWalker.setLogging(level);
return modified;
}
/**
* Apply extensions and normalize all schemas. This may be a multipass process, since applying extensions may create
* the opportunity for further normalizations and vice versa.
*/
public void applyAndNormalize() {
// loop until no modifications, with at least one pass of extensions and normalizations
boolean modified = true;
while (processExtensions() || modified) {
// normalize all the schema definitions
modified = false;
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
int count = schema.getChildCount();
boolean instmod = false;
for (int i = 0; i < count; i++) {
SchemaBase child = schema.getChild(i);
Object obj = child.getExtension();
if (obj instanceof GlobalExtension) {
GlobalExtension global = (GlobalExtension)obj;
global.normalize();
if (global.isRemoved()) {
// just eliminate this definition from the schema
schema.detachChild(i);
instmod = true;
}
}
}
if (instmod) {
schema.compactChildren();
modified = true;
}
}
}
// finish by flagging global definitions requiring separate classes
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
SchemaCustom custom = findSchemaset(schema, m_global).getCustomization(schema.getResolver().getId());
if (custom.isGenerateAll()) {
int count = schema.getChildCount();
for (int i = 0; i < count; i++) {
SchemaBase comp = schema.getChild(i);
if (comp.type() == SchemaBase.ELEMENT_TYPE || comp.type() == SchemaBase.COMPLEXTYPE_TYPE) {
Object obj = comp.getExtension();
if (obj instanceof GlobalExtension) {
((GlobalExtension)obj).setIncluded(true);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Set include for definition " + SchemaUtils.describeComponent(comp));
}
}
}
}
}
}
}
/**
* Processes the schemas to remove unused global definitions.
*/
public void pruneDefinitions() {
// start by recursively checking for removable global definitions
int index = 0;
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
s_logger.debug("Checking for unused definitions in schema " + ++index + ": "
+ schema.getResolver().getName());
int count = schema.getChildCount();
for (int i = 0; i < count; i++) {
SchemaBase child = schema.getChild(i);
Object exten = child.getExtension();
if (exten instanceof GlobalExtension) {
// check if global definition is unused and not specifically required
((GlobalExtension)exten).checkRemovable();
}
}
}
// next remove all the definitions flagged in the first step
index = 0;
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
s_logger.debug("Deleting unused definitions in schema " + ++index + ": " + schema.getResolver().getName());
int count = schema.getChildCount();
boolean modified = false;
for (int i = 0; i < count; i++) {
SchemaBase child = schema.getChild(i);
Object exten = child.getExtension();
if (exten instanceof GlobalExtension && ((ComponentExtension)exten).isRemoved()) {
// remove the definition from schema
schema.detachChild(i);
modified = true;
if (s_logger.isDebugEnabled()) {
s_logger.debug(" Removed definition " + ((INamed)child).getQName());
}
}
}
if (modified) {
schema.compactChildren();
}
}
}
/**
* Write schema definitions to file system.
*
* @param destdir destination directory
* @throws JiBXException on error in marshalling
* @throws IOException on error writing
*/
private void writeSchemas(File destdir) throws JiBXException, IOException {
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
File file = new File(destdir, schema.getResolver().getName());
OutputStream stream = new FileOutputStream(file);
Writer writer = new OutputStreamWriter(stream, "utf-8");
IBindingFactory factory = BindingDirectory.getFactory(SchemaUtils.XS_PREFIX_BINDING, SchemaElement.class);
IMarshallingContext ictx = factory.createMarshallingContext();
ictx.setOutput(writer);
ictx.setIndent(2);
ictx.marshalDocument(schema);
writer.close();
}
}
/**
* Report problems using console output. This clears the problem list after they've been reported, to avoid multiple
* reports of the same problems.
*
* @param vctx
* @return true if one or more errors, false if not
*/
private static boolean reportProblems(ValidationContext vctx) {
ArrayList probs = vctx.getProblems();
boolean error = false;
if (probs.size() > 0) {
for (int j = 0; j < probs.size(); j++) {
ValidationProblem prob = (ValidationProblem)probs.get(j);
String text;
if (prob.getSeverity() >= ValidationProblem.ERROR_LEVEL) {
error = true;
text = "Error: " + prob.getDescription();
s_logger.error(text);
} else {
text = "Warning: " + prob.getDescription();
s_logger.info(text);
}
System.out.println(text);
}
}
probs.clear();
return error;
}
/**
* Add the schemas specified by customizations to the set to be loaded.
*
* @param base root URL for schemas
* @param dir root directory for schemas
* @param custom schema set customization
* @param fileset set of schema files to be loaded
* @throws MalformedURLException
*/
private static void addCustomizedSchemas(URL base, File dir, SchemasetCustom custom, InsertionOrderedSet fileset)
throws MalformedURLException {
// first check for name match patterns supplied
String[] names = custom.getNames();
if (names != null) {
for (int i = 0; i < names.length; i++) {
SchemaNameFilter filter = new SchemaNameFilter();
String name = names[i];
filter.setPattern(name);
s_logger.debug("Matching file names to schemaset pattern '" + name + '\'');
String[] matches = dir.list(filter);
for (int j = 0; j < matches.length; j++) {
String match = matches[j];
fileset.add(new UrlResolver(match, new URL(base, match)));
s_logger.debug("Added schema from schemaset pattern match: " + match);
}
}
}
// next check all child customizations
LazyList childs = custom.getChildren();
for (int i = 0; i < childs.size(); i++) {
Object child = childs.get(i);
if (child instanceof SchemaCustom) {
String name = ((SchemaCustom)child).getName();
if (name != null) {
try {
fileset.add(new UrlResolver(name, new URL(base, name)));
s_logger.debug("Added schema from customizations: " + name);
} catch (MalformedURLException e) {
System.out.println("Error adding schema from customizations: " + name);
}
}
} else if (child instanceof SchemasetCustom) {
addCustomizedSchemas(base, dir, (SchemasetCustom)child, fileset);
}
}
}
/**
* Run the schema refactoring using command line parameters.
*
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
TreeWalker.setLogging(Level.ERROR);
RefactoryCommandLine parms = new RefactoryCommandLine();
if (args.length > 0 && parms.processArgs(args)) {
// build set of schemas specified on command line (including via wildcards)
InsertionOrderedSet fileset = new InsertionOrderedSet();
URL base = parms.getSchemaRoot();
File basedir = parms.getSchemaDir();
SchemaNameFilter filter = new SchemaNameFilter();
boolean err = false;
for (Iterator iter = parms.getExtraArgs().iterator(); iter.hasNext();) {
String name = (String)iter.next();
if (name.indexOf('*') >= 0) {
if (basedir == null) {
System.err.println("File name pattern argument not allowed for non-file base: '" + name + '\'');
} else {
filter.setPattern(name);
s_logger.debug("Matching file names to command line pattern '" + name + '\'');
String[] matches = basedir.list(filter);
for (int i = 0; i < matches.length; i++) {
String match = matches[i];
fileset.add(new UrlResolver(match, new URL(base, match)));
}
}
} else {
if (basedir == null) {
URL url = new URL(base, name);
s_logger.debug("Adding schema URL from command line: " + url.toExternalForm());
fileset.add(new UrlResolver(name, url));
} else {
File sfile = new File(basedir, name);
if (sfile.exists()) {
s_logger.debug("Adding schema file from command line: " + sfile.getCanonicalPath());
fileset.add(new UrlResolver(name, new URL(base, name)));
} else {
System.err.println("Schema file from command line not found: " + sfile.getAbsolutePath());
err = true;
}
}
}
}
if (!err) {
// add any schemas specified in customizations
addCustomizedSchemas(base, basedir, parms.getCustomRoot(), fileset);
// load the full set of schemas
Refactory inst = new Refactory(parms);
SchemaElement[] schemas = inst.load(fileset.asList());
if (!reportProblems(inst.m_validationContext)) {
if (inst.customizeSchemas()) {
System.out.println("Loaded and validated " + fileset.size() + " schemas");
// apply the customizations to the schema
inst.applyAndNormalize();
inst.pruneDefinitions();
// revalidate and write the schemas
inst.validateSchemas(schemas);
inst.writeSchemas(parms.getGeneratePath());
}
}
}
} else {
if (args.length > 0) {
System.err.println("Terminating due to command line errors");
} else {
parms.printUsage();
}
System.exit(1);
}
}
/**
* File name pattern matcher.
*/
private static class SchemaNameFilter implements FilenameFilter
{
/** Current match pattern. */
private String m_pattern;
/**
* Set the match pattern.
*
* @param pattern
*/
public void setPattern(String pattern) {
m_pattern = pattern;
}
/**
* Check for file name match.
*
* @param dir
* @param name
* @return match flag
*/
public boolean accept(File dir, String name) {
boolean match = NameUtilities.isPatternMatch(name, m_pattern);
if (match) {
s_logger.debug(" matched file name '" + name + '\'');
}
return match;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/ArrayAccessBuilder.java 0000644 0001750 0001750 00000005210 10713703146 027065 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.ArrayAccess;
import org.eclipse.jdt.core.dom.Expression;
/**
* Abstract syntax tree array access expression builder. This adds convenience methods and control information to the
* base builder.
*/
public class ArrayAccessBuilder extends ExpressionBuilderBase
{
/** Array creation expression. */
private final ArrayAccess m_arrayAccess;
/**
* Constructor.
*
* @param source
* @param expr
*/
public ArrayAccessBuilder(ClassBuilder source, ArrayAccess expr) {
super(source, expr);
m_arrayAccess = expr;
}
/**
* Add operand to expression. This just sets the supplied operand expression as the index value, as long as the
* index has not been set previously.
*
* @param operand
*/
protected void addOperand(Expression operand) {
Expression index = m_arrayAccess.getIndex();
if (index == null) {
m_arrayAccess.setIndex(operand);
} else {
throw new IllegalStateException("Internal error: attempt to set index expression more than once");
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/FieldBuilder.java 0000644 0001750 0001750 00000006502 11152052550 025707 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.StringLiteral;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
/**
* Abstract syntax tree field declaration builder. This adds convenience methods and control information to the base
* builder.
*/
public class FieldBuilder extends BodyBuilderBase
{
/** Field invocation. */
private final FieldDeclaration m_field;
/**
* Constructor.
*
* @param source
* @param field
*/
public FieldBuilder(ClassBuilder source, FieldDeclaration field) {
super(source, field);
m_field = field;
}
/**
* Get the field declaration.
*
* @return declaration
*/
public FieldDeclaration getDeclaration() {
return m_field;
}
/**
* Set initializer expression for field declaration.
*
* @param expr
*/
public void setInitializer(ExpressionBuilderBase expr) {
VariableDeclarationFragment frag = (VariableDeclarationFragment)m_field.fragments().get(0);
frag.setInitializer(expr.getExpression());
}
/**
* Set initializer as a string literal.
*
* @param value
*/
public void setStringInitializer(String value) {
VariableDeclarationFragment frag = (VariableDeclarationFragment)m_field.fragments().get(0);
StringLiteral literal = m_ast.newStringLiteral();
literal.setLiteralValue(value);
frag.setInitializer(literal);
}
/**
* Set initializer as a number literal.
*
* @param value
*/
public void setNumberInitializer(String value) {
VariableDeclarationFragment frag = (VariableDeclarationFragment)m_field.fragments().get(0);
frag.setInitializer(m_ast.newNumberLiteral(value));
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/MethodBuilder.java 0000644 0001750 0001750 00000007172 11363421526 026117 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.Type;
/**
* Abstract syntax tree method declaration builder. This adds convenience methods and control information to the base
* builder.
*/
public class MethodBuilder extends BodyBuilderBase
{
/** Method invocation. */
private final MethodDeclaration m_method;
/**
* Constructor.
*
* @param source
* @param method
*/
public MethodBuilder(ClassBuilder source, MethodDeclaration method) {
super(source, method);
m_method = method;
}
/**
* Get the method declaration.
*
* @return declaration
*/
public MethodDeclaration getDeclaration() {
return m_method;
}
/**
* Add a method parameter.
*
* @param name
* @param type
* @return declaration
*/
public SingleVariableDeclaration addParameter(String name, Type type) {
SingleVariableDeclaration vdecl = m_ast.newSingleVariableDeclaration();
vdecl.setType(type);
vdecl.setName(m_ast.newSimpleName(name));
m_method.parameters().add(vdecl);
return vdecl;
}
/**
* Add a method parameter.
*
* @param name
* @param type fully-qualfied type name, or primitive name, with optional array suffixes
* @return declaration
*/
public SingleVariableDeclaration addParameter(String name, String type) {
return addParameter(name, m_source.createType(type));
}
/**
* Add an exception type to those thrown by the method.
*
* @param type exception type
*/
public void addThrows(String type) {
m_method.thrownExceptions().add(m_source.createTypeName(type));
}
/**
* Create a block builder for the method body.
*
* @return builder
*/
public BlockBuilder createBlock() {
Block block = m_ast.newBlock();
m_method.setBody(block);
return new BlockBuilder(m_source, block);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/ClassBuilder.java 0000644 0001750 0001750 00000061527 11256241372 025750 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
import org.eclipse.jdt.core.dom.ArrayAccess;
import org.eclipse.jdt.core.dom.ArrayCreation;
import org.eclipse.jdt.core.dom.BodyDeclaration;
import org.eclipse.jdt.core.dom.CastExpression;
import org.eclipse.jdt.core.dom.ClassInstanceCreation;
import org.eclipse.jdt.core.dom.EnumConstantDeclaration;
import org.eclipse.jdt.core.dom.EnumDeclaration;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.InfixExpression;
import org.eclipse.jdt.core.dom.Javadoc;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jdt.core.dom.ParameterizedType;
import org.eclipse.jdt.core.dom.PrefixExpression;
import org.eclipse.jdt.core.dom.StringLiteral;
import org.eclipse.jdt.core.dom.TagElement;
import org.eclipse.jdt.core.dom.TextElement;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.core.dom.InfixExpression.Operator;
import org.jibx.runtime.Utility;
/**
* Builder for a class definition. This wraps the AST with convenience methods and added control information.
*/
public class ClassBuilder
{
/** Source file containing this class. */
private final SourceBuilder m_source;
/** Type declaration for class. */
private final ASTNode m_class;
/** Fields added to class. */
private final ArrayList m_fields;
/** Methods added to class. */
private final ArrayList m_methods;
/** Builders for inner classes of this class. */
private final ArrayList m_innerBuilders;
/** Directly-added inner classes of this class. */
private final ArrayList m_innerClasses;
/**
* Constructor.
*
* @param clas
* @param source
*/
ClassBuilder(AbstractTypeDeclaration clas, SourceBuilder source) {
m_source = source;
m_class = clas;
m_fields = new ArrayList();
m_methods = new ArrayList();
m_innerBuilders = new ArrayList();
m_innerClasses = new ArrayList();
}
/**
* Constructor for an inner class.
*
* @param clas
* @param outer
*/
ClassBuilder(AbstractTypeDeclaration clas, ClassBuilder outer) {
this(clas, outer.m_source);
outer.m_innerBuilders.add(this);
}
/**
* Constructor for an anonymous inner class.
*
* @param clas
* @param outer
*/
public ClassBuilder(AnonymousClassDeclaration clas, ClassBuilder outer) {
m_source = outer.m_source;
m_class = clas;
m_fields = null;
m_methods = null;
m_innerBuilders = null;
m_innerClasses = null;
}
/**
* AST access for related classes.
*
* @return AST
*/
AST getAST() {
return m_source.getAST();
}
/**
* Add separately-constructed field declaration.
*
* @param field
*/
public void addField(FieldDeclaration field) {
m_fields.add(ASTNode.copySubtree(getAST(), field));
}
/**
* Add separately-constructed method declaration.
*
* @param method
*/
public void addMethod(MethodDeclaration method) {
m_methods.add(ASTNode.copySubtree(getAST(), method));
}
/**
* Add separately-constructed inner class declaration.
*
* @param type
*/
public void addType(TypeDeclaration type) {
m_innerClasses.add(ASTNode.copySubtree(getAST(), type));
}
/**
* Set the superclass for this class.
*
* @param name
*/
public void setSuperclass(String name) {
if (m_class instanceof TypeDeclaration) {
((TypeDeclaration)m_class).setSuperclassType(createType(name));
} else {
throw new IllegalStateException("Internal error - can't set superclass on an enum or other special type");
}
}
/**
* Create type name.
*
* @param type fully qualified type name
* @return name
*/
Name createTypeName(String type) {
return m_source.createTypeName(type);
}
/**
* Clone an AST node. The cloned node will have no parent.
*
* @param node
* @return clone
*/
public ASTNode clone(ASTNode node) {
return ASTNode.copySubtree(m_source.getAST(), node);
}
/**
* Create type definition. This uses the supplied type name, which may include array suffixes, to construct the
* actual type definition.
*
* @param type fully qualified type name, or primitive type name
* @return constructed typed definition
*/
public Type createType(String type) {
return m_source.createType(type);
}
/**
* Create a parameterized type. Both the type itself and the parameter type are given as names in this variation.
*
* @param type fully qualified type name
* @param param fully qualified parameter type name
* @return type
*/
public Type createParameterizedType(String type, String param) {
return m_source.createParameterizedType(type, param);
}
/**
* Create a parameterized type. The type itself is given as a name, while the parameter type is an actual type in
* this variation.
*
* @param type fully qualified type name
* @param param type parameter
* @return type
*/
public Type createParameterizedType(String type, Type param) {
ParameterizedType ptype = getAST().newParameterizedType(createType(type));
ptype.typeArguments().add(param);
return ptype;
}
/**
* Set source comment for this class.
*
* @param text comment text
*/
public void addSourceComment(String text) {
if (m_class instanceof AbstractTypeDeclaration) {
Javadoc javadoc = getAST().newJavadoc();
TextElement element = getAST().newTextElement();
element.setText(text);
TagElement tag = getAST().newTagElement();
tag.fragments().add(element);
javadoc.tags().add(tag);
((AbstractTypeDeclaration)m_class).setJavadoc(javadoc);
} else {
throw new IllegalStateException("Internal error - cannot add JavaDoc to non-class type");
}
}
/**
* Set the abstract flag for this class.
*/
public void setAbstract() {
if (m_class instanceof TypeDeclaration) {
Modifier modifier = m_source.getAST().newModifier(Modifier.ModifierKeyword.ABSTRACT_KEYWORD);
((TypeDeclaration)m_class).modifiers().add(modifier);
} else {
// should not be possible, but just in case of added types in future
throw new IllegalStateException("Internal error - abstract not supported for class type");
}
}
/**
* Get the interfaces implemented by this class.
*
* @return interface names
*/
public String[] getInterfaces() {
if (m_class instanceof TypeDeclaration) {
List types = ((TypeDeclaration)m_class).superInterfaceTypes();
ArrayList names = new ArrayList();
for (Iterator iter = types.iterator(); iter.hasNext();) {
Type type = (Type)iter.next();
names.add(type.toString());
}
return (String[])names.toArray(new String[names.size()]);
} else if (m_class instanceof EnumDeclaration) {
return Utility.EMPTY_STRING_ARRAY;
} else {
// should not be possible, but just in case of added types in future
throw new IllegalStateException("Internal error - interface not supported for class type");
}
}
/**
* Get the fields defined in this class.
*
* @return fields
*/
public FieldDeclaration[] getFields() {
return (FieldDeclaration[])m_fields.toArray(new FieldDeclaration[m_fields.size()]);
}
/**
* Get the methods defined in this class.
*
* @return methods
*/
public MethodDeclaration[] getMethods() {
return (MethodDeclaration[])m_methods.toArray(new MethodDeclaration[m_methods.size()]);
}
/**
* Add an interface to this class definition.
*
* @param type interface type
*/
public void addInterface(String type) {
if (m_class instanceof TypeDeclaration) {
((TypeDeclaration)m_class).superInterfaceTypes().add(m_source.createType(type));
} else if (m_class instanceof EnumDeclaration) {
((EnumDeclaration)m_class).superInterfaceTypes().add(m_source.createType(type));
} else {
// should not be possible, but just in case of added types in future
throw new IllegalStateException("Internal error - interface not supported for class type");
}
}
/**
* Add JavaDoc to a declaration.
*
* @param doc documentation text, or null if none
* @param decl
*/
public void addJavaDoc(String doc, BodyDeclaration decl) {
if (doc != null) {
Javadoc javadoc = getAST().newJavadoc();
TextElement element = getAST().newTextElement();
element.setText(doc);
TagElement tag = getAST().newTagElement();
tag.fragments().add(element);
javadoc.tags().add(tag);
decl.setJavadoc(javadoc);
}
}
/**
* Add a constant to a Java 5 enum definition. This method is used for enums which use the name as the value.
*
* @param value
* @param doc documentation text, or null if none
*/
public void addEnumConstant(String value, String doc) {
if (m_class instanceof EnumDeclaration) {
EnumConstantDeclaration enumdecl = getAST().newEnumConstantDeclaration();
enumdecl.setName(getAST().newSimpleName(value));
addJavaDoc(doc, enumdecl);
((EnumDeclaration)m_class).enumConstants().add(enumdecl);
} else {
// should not be possible, but just in case of added types in future
throw new IllegalStateException("Internal error - cannot add constant to class type");
}
}
/**
* Add a constant to a Java 5 enum definition. This method is used for enums which have a value separate from the
* name.
*
* @param name
* @param doc documentation text, or null if none
* @param value
*/
public void addEnumConstant(String name, String doc, String value) {
if (m_class instanceof EnumDeclaration) {
EnumConstantDeclaration enumdecl = getAST().newEnumConstantDeclaration();
enumdecl.setName(getAST().newSimpleName(name));
StringLiteral strlit = getAST().newStringLiteral();
strlit.setLiteralValue(value);
enumdecl.arguments().add(strlit);
addJavaDoc(doc, enumdecl);
((EnumDeclaration)m_class).enumConstants().add(enumdecl);
} else {
// should not be possible, but just in case of added types in future
throw new IllegalStateException("Internal error - cannot add constant to class type");
}
}
/**
* Create new instance of array type.
*
* @param type base type name
* @return array creation
*/
public NewArrayBuilder newArrayBuilder(String type) {
ArrayCreation create = getAST().newArrayCreation();
create.setType(getAST().newArrayType(m_source.createType(type)));
return new NewArrayBuilder(this, create);
}
/**
* Build new instance creator of type using a no-argument constructor.
*
* @param type actual type
* @return instance creation
*/
public NewInstanceBuilder newInstance(Type type) {
ClassInstanceCreation create = getAST().newClassInstanceCreation();
create.setType(type);
return new NewInstanceBuilder(this, create);
}
/**
* Build new instance creator of type using a no-argument constructor.
*
* @param type base type name
* @return instance creation
*/
public NewInstanceBuilder newInstance(String type) {
return newInstance(m_source.createType(type));
}
/**
* Build new instance creator of a simple type using a constructor that takes a single string value.
*
* @param type simple type name
* @param value string value to be passed to constructor
* @return instance creation
*/
public NewInstanceBuilder newInstanceFromString(String type, String value) {
ClassInstanceCreation create = getAST().newClassInstanceCreation();
create.setType(createType(type));
StringLiteral literal = getAST().newStringLiteral();
literal.setLiteralValue(value);
create.arguments().add(literal);
return new NewInstanceBuilder(this, create);
}
/**
* Build new instance creator of a simple type using a constructor that takes a pair of string values.
*
* @param type simple type name
* @param value1 first string value to be passed to constructor
* @param value2 second string value to be passed to constructor
* @return instance creation
*/
public NewInstanceBuilder newInstanceFromStrings(String type, String value1, String value2) {
ClassInstanceCreation create = getAST().newClassInstanceCreation();
create.setType(createType(type));
StringLiteral literal = getAST().newStringLiteral();
literal.setLiteralValue(value1);
create.arguments().add(literal);
literal = getAST().newStringLiteral();
literal.setLiteralValue(value2);
create.arguments().add(literal);
return new NewInstanceBuilder(this, create);
}
/**
* Add field declaration.
*
* @param name field name
* @param type field type
* @return field builder
*/
public FieldBuilder addField(String name, Type type) {
VariableDeclarationFragment vfrag = getAST().newVariableDeclarationFragment();
vfrag.setName(getAST().newSimpleName(name));
FieldDeclaration fdecl = getAST().newFieldDeclaration(vfrag);
fdecl.setType(type);
m_fields.add(fdecl);
return new FieldBuilder(this, fdecl);
}
/**
* Add field declaration.
*
* @param name field name
* @param type type name
* @return field builder
*/
public FieldBuilder addField(String name, String type) {
return addField(name, m_source.createType(type));
}
/**
* Add int field declaration with constant initialization.
*
* @param name variable name
* @param value initial value
* @return field builder
*/
public FieldBuilder addIntField(String name, String value) {
FieldBuilder field = addField(name, "int");
field.setNumberInitializer(value);
return field;
}
/**
* Add constructor declaration.
*
* @param name simple class name
* @return constructor builder
*/
public MethodBuilder addConstructor(String name) {
MethodDeclaration constr = getAST().newMethodDeclaration();
constr.setName(getAST().newSimpleName(name));
constr.setConstructor(true);
m_methods.add(constr);
return new MethodBuilder(this, constr);
}
/**
* Add method declaration.
*
* @param name
* @param type
* @return method builder
*/
public MethodBuilder addMethod(String name, Type type) {
MethodDeclaration meth = getAST().newMethodDeclaration();
meth.setName(getAST().newSimpleName(name));
meth.setConstructor(false);
meth.setReturnType2(type);
if (m_class instanceof AnonymousClassDeclaration) {
((AnonymousClassDeclaration)m_class).bodyDeclarations().add(meth);
} else {
m_methods.add(meth);
}
return new MethodBuilder(this, meth);
}
/**
* Add method declaration.
*
* @param name
* @param type fully qualified type name or primitive type name, with optional array suffixes
* @return method builder
*/
public MethodBuilder addMethod(String name, String type) {
return addMethod(name, m_source.createType(type));
}
/**
* Create internal member method call builder.
*
* @param mname method name
* @return builder
*/
public InvocationBuilder createMemberMethodCall(String mname) {
MethodInvocation methcall = getAST().newMethodInvocation();
methcall.setName(getAST().newSimpleName(mname));
return new InvocationBuilder(this, methcall);
}
/**
* Create internal static method call builder.
*
* @param mname method name
* @return builder
*/
public InvocationBuilder createLocalStaticMethodCall(String mname) {
MethodInvocation methcall = getAST().newMethodInvocation();
methcall.setName(getAST().newSimpleName(mname));
return new InvocationBuilder(this, methcall);
}
/**
* Create a static method call builder.
*
* @param cname fully qualified class name
* @param mname method name
* @return builder
*/
public InvocationBuilder createStaticMethodCall(String cname, String mname) {
MethodInvocation methcall = getAST().newMethodInvocation();
methcall.setExpression(getAST().newName(cname));
methcall.setName(getAST().newSimpleName(mname));
return new InvocationBuilder(this, methcall);
}
/**
* Create a static method call builder.
*
* @param fname fully-qualified class and method name
* @return builder
*/
public InvocationBuilder createStaticMethodCall(String fname) {
int split = fname.lastIndexOf('.');
return createStaticMethodCall(fname.substring(0, split), fname.substring(split+1));
}
/**
* Create method call builder on a local variable or field value.
*
* @param name local variable or field name
* @param mname method name
* @return builder
*/
public InvocationBuilder createNormalMethodCall(String name, String mname) {
MethodInvocation methcall = getAST().newMethodInvocation();
methcall.setExpression(getAST().newSimpleName(name));
methcall.setName(getAST().newSimpleName(mname));
return new InvocationBuilder(this, methcall);
}
/**
* Create method call builder on the reference result of an expression.
*
* @param expr instance expression
* @param mname method name
* @return builder
*/
public InvocationBuilder createExpressionMethodCall(ExpressionBuilderBase expr, String mname) {
MethodInvocation methcall = getAST().newMethodInvocation();
methcall.setExpression(expr.getExpression());
methcall.setName(getAST().newSimpleName(mname));
return new InvocationBuilder(this, methcall);
}
/**
* Build general infix expression.
*
* @param op operator
* @return expression
*/
public InfixExpressionBuilder buildInfix(Operator op) {
InfixExpression infixex = getAST().newInfixExpression();
infixex.setOperator(op);
return new InfixExpressionBuilder(this, infixex);
}
/**
* Build infix expression involving a local variable or field name as the left operand.
*
* @param name local variable or field name
* @param op operator
* @return expression
*/
public InfixExpressionBuilder buildNameOp(String name, Operator op) {
InfixExpression infixex = getAST().newInfixExpression();
infixex.setOperator(op);
return new InfixExpressionBuilder(this, infixex, getAST().newSimpleName(name));
}
/**
* Build a string concatenation expression starting from from a string literal.
*
* @param text literal text
* @return string concatenation expression
*/
public InfixExpressionBuilder buildStringConcatenation(String text) {
InfixExpression expr = getAST().newInfixExpression();
StringLiteral strlit = getAST().newStringLiteral();
strlit.setLiteralValue(text);
expr.setOperator(Operator.PLUS);
return new InfixExpressionBuilder(this, expr, strlit);
}
/**
* Build a preincrement expression using a local variable or field name as the operand.
*
* @param name local variable or field name
* @return expression
*/
public PrefixExpressionBuilder buildPreincrement(String name) {
PrefixExpression prefixex = getAST().newPrefixExpression();
prefixex.setOperator(PrefixExpression.Operator.INCREMENT);
return new PrefixExpressionBuilder(this, prefixex, getAST().newSimpleName(name));
}
/**
* Build a cast expression.
*
* @param type result type
* @return expression
*/
public CastBuilder buildCast(Type type) {
CastExpression castex = getAST().newCastExpression();
castex.setType(type);
return new CastBuilder(this, castex);
}
/**
* Build a cast expression.
*
* @param type result type
* @return expression
*/
public CastBuilder buildCast(String type) {
return buildCast(createType(type));
}
/**
* Build array access expression for a named array variable and named index variable.
*
* @param aname
* @param iname
* @return array access
*/
public ArrayAccessBuilder buildArrayIndexAccess(String aname, String iname) {
ArrayAccess access = getAST().newArrayAccess();
access.setArray(getAST().newSimpleName(aname));
access.setIndex(getAST().newSimpleName(iname));
return new ArrayAccessBuilder(this, access);
}
/**
* Create a new block.
*
* @return block builder
*/
public BlockBuilder newBlock() {
return new BlockBuilder(this, getAST().newBlock());
}
/**
* Finish building the source file data structures.
*/
public void finish() {
if (m_class instanceof AbstractTypeDeclaration) {
List decls = ((AbstractTypeDeclaration)m_class).bodyDeclarations();
decls.addAll(m_fields);
decls.addAll(m_methods);
for (int i = 0; i < m_innerBuilders.size(); i++) {
ClassBuilder builder = (ClassBuilder)m_innerBuilders.get(i);
builder.finish();
decls.add(builder.m_class);
}
decls.addAll(m_innerClasses);
}
}
/**
* Get a sorted array of the field names and types defined in this class.
*
* @return sorted pairs
*/
public StringPair[] getSortedFields() {
StringPair[] pairs = new StringPair[m_fields.size()];
for (int i = 0; i < m_fields.size(); i++) {
FieldDeclaration field = (FieldDeclaration)m_fields.get(i);
String name = ((VariableDeclarationFragment)field.fragments().get(0)).getName().toString();
pairs[i] = new StringPair(name, field.getType().toString());
}
Arrays.sort(pairs);
return pairs;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/InfixExpressionBuilder.java 0000644 0001750 0001750 00000006127 10767276700 030044 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.InfixExpression;
/**
* Abstract syntax tree infix expression builder. This adds convenience methods and control information to the base
* builder.
*/
public class InfixExpressionBuilder extends ExpressionBuilderBase
{
/** Method invocation. */
private final InfixExpression m_expression;
/** Number of operands added to expression. */
private int m_operandCount;
/**
* Constructor.
*
* @param source
* @param expr
*/
public InfixExpressionBuilder(ClassBuilder source, InfixExpression expr) {
super(source, expr);
m_expression = expr;
}
/**
* Constructor with left operand supplied.
*
* @param source
* @param expr
* @param operand
*/
public InfixExpressionBuilder(ClassBuilder source, InfixExpression expr, Expression operand) {
super(source, expr);
m_expression = expr;
addOperand(operand);
}
/**
* Add operand to expression. If the right operand has not yet been set this will set it; otherwise, it will add the
* operand as an extended operand of the expression.
*
* @param operand
*/
protected void addOperand(Expression operand) {
if (m_operandCount == 0) {
m_expression.setLeftOperand(operand);
} else if (m_operandCount == 1) {
m_expression.setRightOperand(operand);
} else {
m_expression.extendedOperands().add(operand);
}
m_operandCount++;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/AnyItem.java 0000644 0001750 0001750 00000006452 11126620772 024737 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.elements.AnnotatedBase;
/**
* Information for an xs:any item to be included in code generated from schema.
*
* @author Dennis M. Sosnoski
*/
public class AnyItem extends Item
{
/**
* Copy constructor. This creates a copy with a new parent.
*
* @param original
* @param ref reference (for overrides to copy; null if none)
* @param parent
*/
private AnyItem(AnyItem original, Item ref, GroupItem parent) {
super(original, ref, original.getComponentExtension(), parent);
}
/**
* Constructor.
*
* @param comp schema component extension
* @param parent containing structure (null if a top-level structure)
*/
/*package*/ AnyItem(AnnotatedBase comp, GroupItem parent) {
super(comp, parent);
}
/**
* Copy the item under a different parent.
*
* @param ref reference (for overrides to copy; null if none)
* @param parent
* @return copy
*/
protected Item copy(Item ref, GroupItem parent) {
return new AnyItem(this, ref, parent);
}
/**
* Build a description of the item.
*
* @param depth current nesting depth
* @param classified include classification details flag
* @return description
*/
protected String describe(int depth, boolean classified) {
StringBuffer buff = new StringBuffer(depth + 50);
buff.append(leadString(depth));
buff.append("any ");
buff.append(" with value name ");
buff.append(getName());
buff.append(": ");
buff.append(SchemaUtils.describeComponent(getSchemaComponent()));
buff.append('\n');
return buff.toString();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/CodeGen.java 0000644 0001750 0001750 00000310632 11427265660 024700 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.eclipse.jdt.core.dom.AST;
import org.jibx.binding.model.BindingElement;
import org.jibx.binding.model.BindingHolder;
import org.jibx.binding.model.BindingOrganizer;
import org.jibx.binding.model.ElementBase;
import org.jibx.binding.model.FormatElement;
import org.jibx.binding.model.MappingElement;
import org.jibx.binding.model.MappingElementBase;
import org.jibx.binding.model.NamespaceElement;
import org.jibx.binding.model.StructureElement;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.runtime.Utility;
import org.jibx.schema.INamed;
import org.jibx.schema.IReference;
import org.jibx.schema.ISchemaResolver;
import org.jibx.schema.SchemaContextTracker;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.SchemaVisitor;
import org.jibx.schema.TreeWalker;
import org.jibx.schema.UrlResolver;
import org.jibx.schema.codegen.custom.ComponentExtension;
import org.jibx.schema.codegen.custom.GlobalExtension;
import org.jibx.schema.codegen.custom.SchemaCustom;
import org.jibx.schema.codegen.custom.SchemaExtension;
import org.jibx.schema.codegen.custom.SchemasetCustom;
import org.jibx.schema.codegen.extend.ClassDecorator;
import org.jibx.schema.codegen.extend.NameConverter;
import org.jibx.schema.elements.AnnotatedBase;
import org.jibx.schema.elements.AttributeElement;
import org.jibx.schema.elements.AttributeGroupRefElement;
import org.jibx.schema.elements.CommonTypeDerivation;
import org.jibx.schema.elements.ComplexTypeElement;
import org.jibx.schema.elements.ElementElement;
import org.jibx.schema.elements.GroupRefElement;
import org.jibx.schema.elements.OpenAttrBase;
import org.jibx.schema.elements.SchemaBase;
import org.jibx.schema.elements.SchemaElement;
import org.jibx.schema.elements.SimpleRestrictionElement;
import org.jibx.schema.elements.SimpleTypeElement;
import org.jibx.schema.elements.UnionElement;
import org.jibx.schema.support.SchemaTypes;
import org.jibx.schema.validation.ProblemConsoleLister;
import org.jibx.schema.validation.ProblemHandler;
import org.jibx.schema.validation.ProblemLogLister;
import org.jibx.schema.validation.ProblemMultiHandler;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.schema.validation.ValidationProblem;
import org.jibx.schema.validation.ValidationUtils;
import org.jibx.util.ClasspathUrlExtender;
import org.jibx.util.DummyClassLocator;
import org.jibx.util.IClassLocator;
import org.jibx.util.InsertionOrderedSet;
import org.jibx.util.LazyList;
import org.jibx.util.ResourceMatcher;
/**
* Code generator from schema definition. Although many of the methods in this class use public access,
* they are intended for use only by the JiBX developers and may change from one release to the next. To make use of
* this class from your own code, call the {@link #main(String[])} method with an appropriate argument list.
*
* @author Dennis M. Sosnoski
*/
public class CodeGen
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(CodeGen.class.getName());
/** Default type replacements applied. */
private static final QName[] DEFAULT_REPLACEMENTS =
new QName[] {
SchemaTypes.ANY_URI.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.DURATION.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.ENTITIES.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.ENTITY.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.GDAY.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.GMONTH.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.GMONTHDAY.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.GYEAR.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.GYEARMONTH.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.ID.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.IDREF.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.IDREFS.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.LANGUAGE.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.NAME.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.NEGATIVE_INTEGER.getQName(), SchemaTypes.INTEGER.getQName(),
SchemaTypes.NON_NEGATIVE_INTEGER.getQName(), SchemaTypes.INTEGER.getQName(),
SchemaTypes.NON_POSITIVE_INTEGER.getQName(), SchemaTypes.INTEGER.getQName(),
SchemaTypes.NORMALIZED_STRING.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.NCNAME.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.NMTOKEN.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.NMTOKENS.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.NOTATION.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.POSITIVE_INTEGER.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.TOKEN.getQName(), SchemaTypes.STRING.getQName(),
SchemaTypes.UNSIGNED_BYTE.getQName(), SchemaTypes.BYTE.getQName(),
SchemaTypes.UNSIGNED_INT.getQName(), SchemaTypes.INT.getQName(),
SchemaTypes.UNSIGNED_LONG.getQName(), SchemaTypes.LONG.getQName(),
SchemaTypes.UNSIGNED_SHORT.getQName(), SchemaTypes.SHORT.getQName()
};
/** Mask for schema elements which derive from a type. */
private static final long TYPE_DERIVE_MASK =
SchemaBase.ELEMENT_MASKS[SchemaBase.EXTENSION_TYPE] | SchemaBase.ELEMENT_MASKS[SchemaBase.RESTRICTION_TYPE];
/** Mask for schema elements which define a type. */
private static final long TYPE_DEFINE_MASK =
SchemaBase.ELEMENT_MASKS[SchemaBase.COMPLEXTYPE_TYPE] | SchemaBase.ELEMENT_MASKS[SchemaBase.SIMPLETYPE_TYPE];
/** Mask for schema elements which block name inheritance downward. */
private static final long BLOCK_NAME_INHERIT_MASK =
TYPE_DERIVE_MASK | SchemaBase.ELEMENT_MASKS[SchemaBase.UNION_TYPE];
/** Code generation customizations. */
private final SchemasetCustom m_global;
/** Target directory for code generation. */
private final File m_targetDir;
/** Context for loading and processing schemas. */
private final ValidationContext m_validationContext;
/** Package directory for generated classes. */
private PackageOrganizer m_packageDirectory;
/** Directory for constructed bindings. */
private BindingOrganizer m_bindingDirectory;
/** Root binding definition holder (set by {@link #writeBindings(String, String, List, ProblemHandler)}). */
private BindingHolder m_rootHolder;
/**
* Constructor.
*
* @param global schema customization root element
* @param root URL for base of schema paths
* @param target destination directory for code generation
*/
public CodeGen(SchemasetCustom global, URL root, File target) {
m_global = global;
addDefaultSubstitutions(m_global);
m_targetDir = target;
m_validationContext = new ValidationContext();
}
/**
* Constructor used by tests. This uses supplied schemas and skips writing to the file system.
*
* @param custom
* @param vctx
*/
public CodeGen(SchemasetCustom custom, ValidationContext vctx) {
m_global = custom;
addDefaultSubstitutions(custom);
m_targetDir = null;
m_validationContext = vctx;
}
/**
* Get the validation context used for processing schemas.
*
* @return context
*/
public ValidationContext getSchemaValidationContext() {
return m_validationContext;
}
/**
* Add default type substitutions to set currently defined.
*
* @param custom
*/
private static void addDefaultSubstitutions(SchemasetCustom custom) {
QName[] subs = custom.getSubstitutions();
if (subs == null) {
custom.setSubstitutions(DEFAULT_REPLACEMENTS);
} else {
QName[] newsubs = new QName[subs.length + DEFAULT_REPLACEMENTS.length];
System.arraycopy(subs, 0, newsubs, 0, subs.length);
System.arraycopy(DEFAULT_REPLACEMENTS, 0, newsubs, subs.length, DEFAULT_REPLACEMENTS.length);
custom.setSubstitutions(newsubs);
}
}
/**
* Find the most specific schemaset owning a schema. If multiple matches are found which are not in line of
* containment the first match is returned and the conflict is reported as an error.
*
* @param schema
* @param custom schema set customization
* @return owning schemaset, null if none
*/
public SchemasetCustom findSchemaset(SchemaElement schema, SchemasetCustom custom) {
LazyList childs = custom.getChildren();
SchemasetCustom owner = null;
String name = schema.getResolver().getName();
for (int i = 0; i < childs.size(); i++) {
Object child = childs.get(i);
if (child instanceof SchemasetCustom) {
SchemasetCustom schemaset = (SchemasetCustom)child;
if (schemaset.isInSet(name, schema)) {
SchemasetCustom match = findSchemaset(schema, schemaset);
if (match != null) {
if (owner == null) {
owner = match;
} else {
m_validationContext.addError("schema-set overlap on schema " + name + " (first match "
+ ValidationProblem.componentDescription(owner) + ')', match);
}
}
}
}
}
return owner == null ? custom : owner;
}
/**
* Scan schemas to find the default prefixes used for namespaces.
*
* @param iter schema iterator
*/
public void setDefaultPrefixes(Iterator iter) {
while (iter.hasNext()) {
SchemaElement schema = (SchemaElement)iter.next();
ArrayList decls = schema.getNamespaceDeclarations();
for (int i = 0; i < decls.size(); i++) {
String prefix = (String)decls.get(i++);
m_bindingDirectory.addDefaultPrefix((String)decls.get(i), prefix);
}
}
}
/**
* Validate and apply customizations to loaded schemas.
*
* @param pack package to be used by default for no-namespaced schemas (non-null)
* @param handler validation problem handler
* @return true if successful, false if error
*/
public boolean customizeSchemas(String pack, ProblemHandler handler) {
// TODO: remove this once list and union handling fully implemented
SchemaVisitor visitor = new SchemaVisitor() {
private void replaceSimpleType(OpenAttrBase node) {
OpenAttrBase parent = node.getParent();
int count = parent.getChildCount();
for (int i = 0; i < count; i++) {
if (parent.getChild(i) == node) {
SimpleRestrictionElement empty = new SimpleRestrictionElement();
empty.setBase(SchemaTypes.STRING.getQName());
parent.replaceChild(i, empty);
return;
}
}
}
/* public void exit(ListElement node) {
replaceSimpleType(node);
} */
public void exit(UnionElement node) {
replaceSimpleType(node);
}
};
TreeWalker wlkr = new TreeWalker(null, new SchemaContextTracker());
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
wlkr.walkElement((SchemaElement)iter.next(), visitor);
}
// // TODO: test code for annotating schema
// try {
// DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
// final Document document = builder.newDocument();
// visitor = new SchemaVisitor() {
//
// public void exit(AnnotatedBase node) {
// if (node.getAnnotation() == null) {
// StringBuffer buff = new StringBuffer();
// buff.append(node.name());
// if (node instanceof INamed && ((INamed)node).getName() != null) {
// buff.append(" name='");
// buff.append(((INamed)node).getName());
// buff.append('\'');
// } else if (node instanceof IReference && ((IReference)node).getRef() != null) {
// buff.append(" ref='");
// buff.append(((IReference)node).getRef().getName());
// buff.append('\'');
// }
// AnnotationElement anno = new AnnotationElement();
// node.setAnnotation(anno);
// DocumentationElement doc = new DocumentationElement();
// doc.addContent(document.createTextNode(buff.toString()));
// anno.getItemsList().add(doc);
// }
// }
//
// };
// for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
// wlkr.walkElement((SchemaElement)iter.next(), visitor);
// }
// } catch (ParserConfigurationException e) {
// /* ignore any error */
// }
// validate the customizations
m_global.validate(m_validationContext);
// create the package directory, using default package from root schemaset
String dfltpack = m_global.getPackage();
if (dfltpack == null) {
dfltpack = pack;
}
m_packageDirectory = new PackageOrganizer(m_targetDir, dfltpack);
// link each schema to a customization, creating a default customization if necessary
int count = 0;
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
ISchemaResolver resolver = schema.getResolver();
s_logger.debug("Assigning customization for schema " + ++count + ": " + resolver.getName());
SchemasetCustom owner = findSchemaset(schema, m_global);
SchemaCustom custom = owner.forceCustomization(resolver.getName(), resolver.getId(), schema,
m_validationContext);
custom.validate(m_validationContext);
String pname = custom.getPackage();
PackageHolder holder = null;
if (pname == null) {
String uri = schema.getEffectiveNamespace();
if (uri == null) {
uri = "";
}
holder = m_packageDirectory.getPackageForUri(uri);
} else {
holder = m_packageDirectory.getPackage(pname);
}
custom.extend(holder, m_validationContext);
}
// check all the customizations
m_global.checkSchemas(m_validationContext);
return !m_validationContext.reportProblems(handler);
}
/**
* Process substitutions and deletions defined by extensions. This builds the cross-reference information for the
* global definition components of the schemas while removing references to deleted components.
*
* @return true if any changes to the schemas, false if not
*/
private boolean processExtensions() {
// first clear all the cross reference information
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
int count = schema.getChildCount();
for (int i = 0; i < count; i++) {
SchemaBase child = schema.getChild(i);
Object obj = child.getExtension();
if (obj instanceof GlobalExtension) {
((GlobalExtension)obj).resetDependencies();
}
}
}
// process each loaded schema for deletions and cross referencing
int index = 0;
m_validationContext.clearTraversed();
boolean modified = false;
// Level level = TreeWalker.setLogging(s_logger.getLevel());
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
m_validationContext.enterSchema(schema);
s_logger.debug("Applying extensions to schema " + ++index + ": " + schema.getResolver().getName());
int count = schema.getChildCount();
boolean instmod = false;
for (int i = 0; i < count; i++) {
SchemaBase child = schema.getChild(i);
Object obj = child.getExtension();
if (obj instanceof GlobalExtension) {
// apply extension to global definition element
ComponentExtension exten = (ComponentExtension)obj;
if (exten.isRemoved()) {
// just eliminate this definition from the schema
schema.detachChild(i);
instmod = true;
} else {
// process the definition to remove references to deleted components
exten.applyAndCountUsage(m_validationContext);
}
}
}
if (instmod) {
schema.compactChildren();
modified = true;
}
m_validationContext.exitSchema();
}
// TreeWalker.setLogging(level);
return modified;
}
/**
* Apply extensions and normalize all schemas. This may be a multipass process, since applying extensions may create
* the opportunity for further normalizations and vice versa.
*/
public void applyAndNormalize() {
// loop until no modifications, with at least one pass of extensions and normalizations
boolean modified = true;
while (processExtensions() || modified) {
// normalize all the schema definitions
modified = false;
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
int count = schema.getChildCount();
boolean instmod = false;
for (int i = 0; i < count; i++) {
SchemaBase child = schema.getChild(i);
Object obj = child.getExtension();
if (obj instanceof GlobalExtension) {
GlobalExtension global = (GlobalExtension)obj;
global.normalize();
if (global.isRemoved() ||
(!global.isIncluded() && global.isPreferInline() && global.getOverrideType() != null)) {
// just eliminate this definition from the schema
schema.detachChild(i);
instmod = true;
}
}
}
if (instmod) {
schema.compactChildren();
modified = true;
}
}
}
// finish by flagging global definitions requiring separate classes
TreeWalker wlkr = new TreeWalker(null, new SchemaContextTracker());
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
SchemaCustom custom = ((SchemaExtension)schema.getExtension()).getCustom();
if (custom.isGenerateAll()) {
int count = schema.getChildCount();
for (int i = 0; i < count; i++) {
// check if this global needs a class
SchemaBase comp = schema.getChild(i);
boolean include = false;
switch (comp.type()) {
/* case SchemaBase.ATTRIBUTE_TYPE:
include = !custom.isAttributeInlined();
break; */
case SchemaBase.ATTRIBUTEGROUP_TYPE:
case SchemaBase.GROUP_TYPE:
// for attribute group or group, only force separate class if multiple components
ValueCountVisitor visitor = new ValueCountVisitor();
wlkr.walkChildren(comp, visitor);
include = visitor.getCount() > 1;
break;
case SchemaBase.COMPLEXTYPE_TYPE:
case SchemaBase.ELEMENT_TYPE:
include = true;
break;
case SchemaBase.SIMPLETYPE_TYPE:
// for simpleType definition, only need separate class if an enumeration
if (comp.getChildCount() > 0) {
SchemaBase deriv = ((SimpleTypeElement)comp).getDerivation();
include = deriv != null && deriv.type() == SchemaBase.RESTRICTION_TYPE &&
((SimpleRestrictionElement)deriv).getFacetsList().size() > 0;
}
break;
}
if (include) {
// flag separate class for global
Object obj = comp.getExtension();
if (obj instanceof GlobalExtension) {
((GlobalExtension)obj).setIncluded(true);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Set include for definition " + SchemaUtils.describeComponent(comp));
}
}
}
}
}
}
}
/**
* Processes the schemas to remove unused global definitions.
*/
public void pruneDefinitions() {
// start by recursively checking for removable global definitions
int index = 0;
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
s_logger.debug("Checking for unused definitions in schema " + ++index + ": "
+ schema.getResolver().getName());
int count = schema.getChildCount();
for (int i = 0; i < count; i++) {
SchemaBase child = schema.getChild(i);
Object exten = child.getExtension();
if (exten instanceof GlobalExtension) {
// check if global definition is unused and not specifically required
((GlobalExtension)exten).checkRemovable();
}
}
}
// next remove all the definitions flagged in the first step
index = 0;
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
s_logger.debug("Deleting unused definitions in schema " + ++index + ": " + schema.getResolver().getName());
int count = schema.getChildCount();
boolean modified = false;
for (int i = 0; i < count; i++) {
SchemaBase child = schema.getChild(i);
Object exten = child.getExtension();
if (exten instanceof GlobalExtension && ((ComponentExtension)exten).isRemoved()) {
// remove the definition from schema
schema.detachChild(i);
modified = true;
if (s_logger.isDebugEnabled()) {
s_logger.debug(" Removed definition " + ((INamed)child).getQName());
}
}
}
if (modified) {
schema.compactChildren();
}
}
}
/**
* Check if an item has an associated name. If the component associated with the item has a name, this just returns
* that name converted to base name form. The only exception is for inlined global type definitions, which are
* treated as unnamed.
*
* @param item
* @return name associated name, or null if none
*/
private String checkDirectName(Item item) {
AnnotatedBase comp = item.getSchemaComponent();
if (comp instanceof INamed || comp instanceof IReference) {
// check for an inlined global type definition
boolean usename = true;
if (comp.isGlobal()) {
if ((comp.bit() & TYPE_DEFINE_MASK) != 0 && !(item instanceof DefinitionItem)) {
usename = false;
}
}
if (usename) {
// use name from schema component
String name = null;
if (comp instanceof INamed) {
name = ((INamed)comp).getName();
}
if (name == null && comp instanceof IReference) {
name = ((IReference)comp).getRef().getName();
}
if (name != null) {
NameConverter nconv = item.getComponentExtension().getGlobal().getNameConverter();
return nconv.toBaseName(name);
}
}
}
return null;
}
/**
* Derive the base name for an item. If not forced, the only time a name will be returned is when the item is a
* reference to a non-type definition. If forced, this will try other alternatives for names including the text
* "Enumeration" for an enumeration group, the base type name for a type derivation, the schema type name for a
* value of a schema type, or finally the schema component element name.
*
* @param item
* @param force name forced flag
* @return name (null if to use inherited name when force == false)
*/
private String deriveName(Item item, boolean force) {
// try alternatives, in decreasing preference order
AnnotatedBase comp = item.getSchemaComponent();
String text = null;
if (force) {
if (item instanceof ReferenceItem) {
text = ((ReferenceItem)item).getDefinition().getName();
} else if (item instanceof GroupItem && ((GroupItem)item).isEnumeration()) {
text = "Enumeration";
} else if ((TYPE_DERIVE_MASK & comp.bit()) != 0 && ((CommonTypeDerivation)comp).getBase() != null) {
text = ((CommonTypeDerivation)comp).getBase().getName();
} else if (item instanceof ValueItem) {
text = ((ValueItem)item).getSchemaType().getName();
} else {
text = comp.name();
}
} else if (item instanceof ReferenceItem && (TYPE_DEFINE_MASK & comp.type()) == 0) {
// use name from definition in the case of anything except a type definition
text = ((ReferenceItem)item).getDefinition().getName();
}
if (text == null) {
return null;
} else {
return item.getComponentExtension().getGlobal().getNameConverter().toBaseName(text);
}
}
/**
* Compact group structures. This eliminates redundant groupings, in the form of groups with only one child, which
* child is a group referencing the same schema component as the parent group, from the data structure
* representation.
*
* @param group
*/
private void compactGroups(GroupItem group) {
Item child;
while (group.getChildCount() == 1 && (child = group.getFirstChild()) instanceof GroupItem &&
!child.isTopmost()) {
group.adoptChildren((GroupItem)child);
}
for (child = group.getFirstChild(); child != null; child = child.getNext()) {
if (child instanceof GroupItem) {
compactGroups((GroupItem)child);
}
}
}
/**
* Assemble a name from a base name and an optional prefix. If the prefix is supplied, this first converts the base
* name to embedded form, then appends the prefix.
*
* @param prefix
* @param base
* @return name
*/
private String assembleName(String prefix, String base) {
if (prefix == null) {
return base;
} else {
return prefix + NameUtils.toNameWord(base);
}
}
/**
* Set the basic names to be used for a structure of items. For named components of the schema definition the names
* used are simply the converted XML local names, for other components more complex rules apply (see {@link
* #deriveName(Item,boolean)}. This method calls itself recursively to handle nested groups.
*
* @param prefix text to be prefixed to names within inlined group (null if none)
* @param group item group to be assigned
* @param force force name derivation flag
*/
private void assignNames(String prefix, GroupItem group, boolean force) {
// use existing name if set, otherwise derive from context if necessary
String name = group.getName();
AnnotatedBase comp = group.getSchemaComponent();
int type = comp.type();
boolean propagate = group.getChildCount() == 1 &&
(type == SchemaBase.ELEMENT_TYPE || type == SchemaBase.ATTRIBUTE_TYPE);
if (name == null) {
name = checkDirectName(group);
if (name == null && force) {
propagate = false;
name = deriveName(group, true);
}
}
// set name needed for this structure (as either value or class)
if (name != null) {
if (group.getClassName() == null) {
NameConverter conv = group.getComponentExtension().getGlobal().getNameConverter();
group.setClassName(conv.toJavaClassName(name));
}
if (group.getName() == null) {
group.setName(NameUtils.toNameLead(assembleName(prefix, name)));
}
}
// set passed-down prefix to this name if inline group with element name and more than one child, or multiple
// nested children and no passed-in prefix
if (group.isInline() && name != null) {
if (comp.type() == SchemaBase.ELEMENT_TYPE && SchemaUtils.isNamed(comp)) {
boolean passprefix = false;
if (group.getChildCount() > 1) {
passprefix = true;
} else if (prefix == null) {
passprefix = true;
GroupItem childgroup = group;
while (childgroup.getChildCount() == 1) {
Item childchild = childgroup.getFirstChild();
if (childchild instanceof GroupItem) {
childgroup = (GroupItem)childchild;
} else {
passprefix = false;
break;
}
}
}
if (passprefix) {
prefix = assembleName(prefix, name);
}
}
}
// propagate name downward if group is inline and single nested item without its own name
Item head = group.getFirstChild();
if (propagate) {
// name can be inherited, but continue recursion for child group
if (head instanceof GroupItem) {
GroupItem childgroup = (GroupItem)head;
assignNames(childgroup.isInline() ? prefix : null, childgroup, false);
}
} else {
// process all child items with definite name assignments
for (Item item = head; item != null; item = item.getNext()) {
if (item instanceof GroupItem) {
GroupItem childgroup = (GroupItem)item;
assignNames(childgroup.isInline() ? prefix : null, childgroup, true);
} else {
if (item.getName() == null) {
String childname = checkDirectName(item);
if (childname == null) {
childname = deriveName(item, true);
}
item.setName(NameUtils.toNameLead(assembleName(prefix, childname)));
}
}
}
}
}
/**
* Compute the complexity of a structure. In order to find the complexity of a structure all items of the structure
* must first be checked for inlining, which in turn requires checking their complexity. That makes this method
* mutually recursive with {@link #checkInline(DefinitionItem, int, List)}.
*
* @param group
* @param depth nesting depth
* @param defs list of generated definitions
* @return complexity (0, 1, or 2 for anything more than a single value)
*/
private int computeComplexity(GroupItem group, int depth, List defs) {
if (s_logger.isDebugEnabled()) {
s_logger.debug(SchemaUtils.getIndentation(depth) + "counting values for "
+ (group instanceof DefinitionItem ? "definition " : "group ")
+ SchemaUtils.describeComponent(group.getSchemaComponent()));
}
// count the actual values in the structure
int count = 0;
for (Item item = group.getFirstChild(); item != null; item = item.getNext()) {
// get the schema customization information
SchemaCustom custom = ((SchemaExtension)item.getSchemaComponent().getSchema().getExtension()).getCustom();
// handle inlining of references
if (item instanceof ReferenceItem) {
// first make sure the definition has been checked for inlining
ReferenceItem reference = (ReferenceItem)item;
DefinitionItem definition = reference.getDefinition();
checkInline(definition, depth + 1, defs);
if (definition.isInline()) {
// convert the reference to an inline copy of the definition
item = reference.inlineReference();
if (s_logger.isDebugEnabled()) {
s_logger.debug(SchemaUtils.getIndentation(depth) + "converted reference to "
+ SchemaUtils.describeComponent(definition.getSchemaComponent()) + " to inline group");
}
}
}
// handle actual item count, and inlining of child group (may be new, from converted reference)
if (item instanceof GroupItem) {
// check count for nested group
GroupItem grpitem = (GroupItem)item;
int grpcount = computeComplexity(grpitem, depth + 1, defs);
// avoid inlining if an enumeration, or an extension reference; or the nested group is optional or a
// collection and has more than one item (or a single item which is itself optional or a collection,
// which will be counted as multiple items); or the main group is a choice, and the nested group is a
// compositor with more than one element, and the first element is optional (or the first element child
// of that element, if inlined) - but allow override from customizations
boolean inline = true;
ComponentExtension exten = grpitem.getComponentExtension();
if (exten.isSeparateClass()) {
inline = false;
} else {
if (grpitem.isEnumeration()) {
inline = false;
} else if (grpitem.isCollection() || grpitem.isOptional()) {
if (grpcount > 1) {
inline = false;
} else {
// must be single child, but block inlining if that child is optional or an element or
// attribute with simple value (since we need an object for the optional part, separate
// from the simple value)
Item child;
GroupItem childgrp = grpitem;
boolean named = false;
while ((child = childgrp.getFirstChild()) instanceof GroupItem) {
childgrp = (GroupItem)child;
if (childgrp.isOptional()) {
inline = false;
break;
}
if (!named && childgrp.isTopmost()) {
int type = childgrp.getSchemaComponent().type();
named = type == SchemaBase.ATTRIBUTE_TYPE || type == SchemaBase.ELEMENT_TYPE;
}
}
if (named && child instanceof ValueItem) {
inline = false;
}
}
} else if (grpcount > 1 && group.getSchemaComponent().type() == SchemaBase.CHOICE_TYPE) {
// assume no inlining, but dig into structure to make sure first non-inlined element is required
inline = false;
Item child = grpitem.getFirstChild();
while (!child.isOptional()) {
if (child.getSchemaComponent().type() == SchemaBase.ELEMENT_TYPE &&
!(child instanceof GroupItem && ((GroupItem)child).isInline())) {
// required element with simple value or separate class, safe to inline
inline = true;
break;
} else if (child instanceof GroupItem) {
child = ((GroupItem)child).getFirstChild();
if (child == null) {
// empty group, safe to inline
inline = true;
break;
}
} else {
// required reference item, safe to inline
inline = true;
break;
}
}
}
}
if (inline) {
// inline the group
if (!grpitem.isInline()) {
grpitem.setInline(true);
}
count += grpcount;
if (s_logger.isDebugEnabled()) {
s_logger.debug(SchemaUtils.getIndentation(depth) + "inlining "
+ (grpitem instanceof DefinitionItem ? "definition " : "group ")
+ SchemaUtils.describeComponent(grpitem.getSchemaComponent()) + " with item count " +
count);
}
} else {
// force separate class for group
grpitem.setInline(false);
count++;
}
} else {
count++;
}
// bump up the complexity if the item is repeated (optionally inlining collection wrappers)
if (!custom.isNullCollectionAllowed() && item.isCollection()) {
count++;
}
}
return count > 1 ? 2 : count;
}
/**
* Check if a group consists only of a single non-repeating item, which is not an enumeration.
*
* @param group
* @return true if simple group, false if repeated, multiple, or enumeration
*/
private boolean isSimple(GroupItem group) {
if (group.isEnumeration() || group.getChildCount() > 1) {
return false;
} else {
for (Item item = group.getFirstChild(); item != null; item = item.getNext()) {
if (item.isCollection()) {
return false;
} else if (item instanceof GroupItem && !isSimple((GroupItem)item)) {
return false;
}
}
return true;
}
}
/**
* Convert nested groups which are not inlined to freestanding definitions. This calls itself recursively to process
* nested groups, except those nested within groups converted to definitions.
*
* @param group
* @param defs list of generated definitions
*/
private void convertToDefinitions(GroupItem group, List defs) {
Item item = group.getFirstChild();
while (item != null) {
if (item instanceof GroupItem) {
GroupItem childgrp = (GroupItem)item;
if (childgrp.isInline()) {
convertToDefinitions(childgrp, defs);
} else {
DefinitionItem def = childgrp.convertToDefinition();
def.setChecked(true);
OpenAttrBase ancestor = group.getSchemaComponent();
while (!ancestor.isGlobal()) {
ancestor = ancestor.getParent();
}
GlobalExtension global = (GlobalExtension)ancestor.getExtension();
PackageHolder pack = global.getPackage();
String clasname = def.getClassName();
NameConverter nconv = global.getNameConverter();
boolean useinner = global.isUseInnerClasses();
ClassDecorator[] decorators = global.getClassDecorators();
BindingHolder holder = m_bindingDirectory.getRequiredBinding(def.getSchemaComponent().getSchema());
ClassHolder clas = pack.addClass(clasname, nconv, decorators, useinner,
childgrp.isEnumeration(), holder);
def.setGenerateClass(clas);
defs.add(def);
s_logger.debug("Added definition class " + clas.getFullName());
}
}
item = item.getNext();
}
}
/**
* Check if a global definition structure is to be inlined. This method is mutually recursive with {@link
* #computeComplexity(GroupItem, int, List)}. The two methods together determine the inlining status of all items.
*
* @param def
* @param depth nesting depth
* @param defs list of generated definitions
*/
private void checkInline(DefinitionItem def, int depth, List defs) {
if (def.isChecked()) {
def.setReferenced(true);
} else if (def.isInline()) {
def.setChecked(true);
} else {
// flag checked and clear referenced to detect circular references
def.setChecked(true);
def.setReferenced(false);
if (s_logger.isDebugEnabled()) {
s_logger.debug(SchemaUtils.getIndentation(depth) + "checking inlining of definition "
+ SchemaUtils.describeComponent(def.getSchemaComponent())
+ (def.isInlineBlocked() ? " (inlining blocked)" : ""));
}
// inline references where appropriate, and count the values defined
int count = computeComplexity(def, depth, defs);
// determine the representation based on customizations or complexity
GlobalExtension exten = (GlobalExtension)def.getComponentExtension();
if (exten.isInlined()) {
if (def.isInlineBlocked()) {
s_logger.error("Cannot inline " + SchemaUtils.describeComponent(def.getSchemaComponent()) + " because of use as collection value, type for global element, or other usage");
} else {
def.setInline(true);
}
} else if (!exten.isSeparateClass() && !def.isInlineBlocked() && (exten.isPushInline() || count == 0 ||
(count == 1 && isSimple(def)) || (exten.isPreferInline() && def.getReferenceCount() == 1))) {
if (def.isReferenced()) {
s_logger.debug(SchemaUtils.getIndentation(depth) + "blocking inlining of self-referencing definition " +
SchemaUtils.describeComponent(def.getSchemaComponent()));
} else {
// set state as inlined
def.setInline(true);
if (s_logger.isDebugEnabled()) {
s_logger.debug(SchemaUtils.getIndentation(depth) + "inlining definition "
+ SchemaUtils.describeComponent(def.getSchemaComponent()) +
" with item count " + count);
}
// convert non-inlined child components to definitions if multiple use
if (def.getReferenceCount() > 1) {
convertToDefinitions(def, defs);
}
}
}
}
}
/**
* Set the name and namespace URI for a concrete <mapping> binding component. This is the same logic as used in
* the {@link StructureClassHolder} equivalent.
*
* @param qname qualified name to be set (null if none)
* @param mapping concrete mapping definition
* @param holder binding containing the mapping
*/
private void setName(QName qname, MappingElementBase mapping, BindingHolder holder) {
if (qname != null) {
String name = qname.getName();
mapping.setName(name);
String uri = qname.getUri();
holder.addNamespaceUsage(uri);
if (!Utility.safeEquals(uri, holder.getElementDefaultNamespace())) {
mapping.setUri(uri);
}
}
}
/**
* Build the structure of items to be used in code generation for each global definition.
*
* @return constructed definition items
*/
private ArrayList buildItemStructures() {
ArrayList items = new ArrayList();
ItemVisitor itembuilder = new ItemVisitor();
int index = 0;
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
m_validationContext.enterSchema(schema);
s_logger.info("Building item structure for schema " + ++index + ": " + schema.getResolver().getName());
int count = schema.getChildCount();
for (int i = 0; i < count; i++) {
SchemaBase child = schema.getChild(i);
if (child.getExtension() instanceof GlobalExtension) {
// create the definition
GlobalExtension global = (GlobalExtension)child.getExtension();
DefinitionItem definition = global.getDefinition();
if (definition == null) {
definition = itembuilder.buildGlobal((AnnotatedBase)child);
if (s_logger.isInfoEnabled()) {
s_logger.info("Constructed item structure for " + SchemaUtils.describeComponent(child)
+ ":\n" + definition.describe());
}
} else if (s_logger.isInfoEnabled()) {
s_logger.info("Found existing item structure for " + SchemaUtils.describeComponent(child)
+ ":\n" + definition.describe());
}
items.add(definition);
// set the names on the definition so they'll be available for inlining
NameConverter nconv = global.getNameConverter();
String dfltname = nconv.toBaseName(((INamed)child).getName());
if (!definition.isFixedName()) {
String name = global.getBaseName();
if (name == null) {
name = NameUtils.toNameLead(dfltname);
}
definition.setName(name);
}
if (!definition.isFixedClassName()) {
String name = global.getClassName();
if (name == null) {
name = global.getNameConverter().toJavaClassName(dfltname);
}
definition.setClassName(name);
}
// force class generation if required
if (global.isIncluded()) {
definition.setInlineBlocked(true);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Forcing class generation for " + SchemaUtils.describeComponent(child));
}
}
}
}
}
return items;
}
/**
* Convert the item model used for global elements, if they're the only reference to a global type. This just
* prevents generating two separate classes, one for the type and one for the element.
*
* @param items global definition items
* @return map from base type definition to singleton element definition using that type
*/
private Map convertTypeIsomorphicElements(ArrayList items) {
// check for special (but common) case of single global element using global complexType
ArrayList checkitems = new ArrayList();
for (int i = 0; i < items.size(); i++) {
DefinitionItem definition = (DefinitionItem)items.get(i);
if (!definition.isPregenerated()) {
// record all simple element definition items separately for next pass
AnnotatedBase child = definition.getSchemaComponent();
if (child.type() == SchemaBase.ELEMENT_TYPE && definition.getChildCount() == 1) {
Item item = definition.getFirstChild();
if (item instanceof ReferenceItem) {
DefinitionItem basedef = ((ReferenceItem)item).getDefinition();
if (!basedef.isPregenerated()) {
AnnotatedBase comp = basedef.getSchemaComponent();
if (comp.type() != SchemaBase.SIMPLETYPE_TYPE) {
checkitems.add(definition);
}
}
}
}
}
}
// build map from type definition used by element to flag for single vs. multiple usage
Map usemap = new HashMap();
for (int i = 0; i < checkitems.size(); i++) {
// make sure the type definition is not using a pregenerated class (since can't be sure won't be reused)
ReferenceItem reference = (ReferenceItem)((DefinitionItem)checkitems.get(i)).getFirstChild();
DefinitionItem basedef = reference.getDefinition();
if (!basedef.hasDirectGenerateClass()) {
Boolean usedirect = (Boolean)usemap.get(basedef);
if (usedirect == null) {
// first time type was referenced, flag to use directly
usemap.put(basedef, Boolean.TRUE);
} else if (usedirect.booleanValue()) {
// second time type was referenced, flag to use separate classes
usemap.put(basedef, Boolean.FALSE);
}
}
}
// flag type-isomorphic elements as inlined, building map from type to isomorphic element definition
HashMap typeinstmap = new HashMap();
for (int i = 0; i < checkitems.size(); i++) {
DefinitionItem elemdef = (DefinitionItem)checkitems.get(i);
ReferenceItem reference = (ReferenceItem)elemdef.getFirstChild();
DefinitionItem basedef = reference.getDefinition();
if (!basedef.hasDirectGenerateClass() && ((Boolean)usemap.get(basedef)).booleanValue()) {
// single element definition using type, make sure abstract state matches on element and type
ElementElement element = (ElementElement)elemdef.getSchemaComponent();
AnnotatedBase refcomp = basedef.getSchemaComponent();
if (!(refcomp instanceof ComplexTypeElement) ||
((ComplexTypeElement)refcomp).isAbstract() == element.isAbstract()) {
// abstract state matches, force class for type but none for element
basedef.setInlineBlocked(true);
elemdef.setInlineBlocked(true);
typeinstmap.put(basedef, elemdef);
elemdef.setTypeIsomorphic(true);
}
}
}
// flag type-isomorphic elements as inlined, building map from type to isomorphic element definition
/* HashMap typeinstmap = new HashMap();
for (int i = 0; i < checkitems.size(); i++) {
DefinitionItem elemdef = (DefinitionItem)checkitems.get(i);
ReferenceItem reference = (ReferenceItem)elemdef.getFirstChild();
DefinitionItem basedef = reference.getDefinition();
if (!basedef.hasDirectGenerateClass() && basedef.getReferenceCount() == 1) {
// single element definition using type, force class for type but none for element
elemdef.setInlineBlocked(false);
elemdef.setInline(true);
typeinstmap.put(basedef, elemdef);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Forcing inlining of type-isomorphic "
+ SchemaUtils.describeComponent(elemdef.getSchemaComponent()));
}
}
} */
return typeinstmap;
}
/**
* Build list of definitions to be generated. Where possible, references are converted to inline definitions. Where
* they can't be converted, new definitions are created for separate class generation.
*
* @param items
* @return definitions to be processed
*/
private ArrayList inlineReferences(ArrayList items) {
ArrayList defs = new ArrayList();
for (int i = 0; i < items.size(); i++) {
// make sure definition has been checked for inlining (may add new definitions directly to list)
DefinitionItem def = (DefinitionItem)items.get(i);
checkInline(def, 1, defs);
// add definition to list if not inlined or pregenerated or type-isomorphic
if (!def.isInline() && !def.hasDirectGenerateClass() && !def.isTypeIsomorphic()) {
GlobalExtension global = (GlobalExtension)def.getComponentExtension();
defs.add(def);
PackageHolder pack = global.getPackage();
String cname = def.getClassName();
NameConverter nconv = global.getNameConverter();
ClassDecorator[] decorators = global.getClassDecorators();
boolean userinner = global.isUseInnerClasses();
BindingHolder holder = m_bindingDirectory.getRequiredBinding(def.getSchemaComponent().getSchema());
ClassHolder clas = pack.addClass(cname, nconv, decorators, userinner, def.isEnumeration(), holder);
def.setGenerateClass(clas);
}
}
return defs;
}
/**
* Check if no-namespace namespace is used in any of the schemas.
*
* @return true if no-namespace used, false if not
*/
private boolean checkNoNamespacedUsed() {
SchemaNameVisitor visitor = new SchemaNameVisitor();
TreeWalker walker = new TreeWalker(null, new SchemaContextTracker());
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
walker.walkSchema((SchemaElement)iter.next(), visitor);
}
return visitor.isNoNamespaceUsed();
}
/**
* Build classes and bindings for all definitions, except those for singleton element definitions using a type.
*
* @param defs definitions to be generated
* @param typeinst map from base type definition to singleton element definition using that type
*/
private void buildClassesAndBindings(ArrayList defs, Map typeinst) {
// process all type definitions
for (int i = 0; i < defs.size(); i++) {
// compact again after inlining and converting extension references
DefinitionItem definition = (DefinitionItem)defs.get(i);
compactGroups(definition);
// build the binding component for this definition
ClassHolder clas = (ClassHolder)definition.getGenerateClass();
OpenAttrBase comp = definition.getSchemaComponent();
SchemaElement schema = comp.getSchema();
BindingHolder holder = m_bindingDirectory.getRequiredBinding(schema);
if (definition.isEnumeration()) {
// construct format and add to binding
FormatElement format = new FormatElement();
format.setTypeName(clas.getBindingName());
format.setQName(definition.getQName());
((EnumerationClassHolder)clas).setBinding(format);
m_bindingDirectory.addFormat(format);
} else {
// construct mapping element
MappingElementBase mapping = new MappingElement();
mapping.setClassName(clas.getBindingName());
if (comp.type() == SchemaBase.ELEMENT_TYPE) {
// abstract or concrete mapping for element
ElementElement element = (ElementElement)comp;
setName(element.getEffectiveQName(), mapping, holder);
mapping.setAbstract(element.isAbstract());
QName group = element.getSubstitutionGroup();
if (group != null) {
ElementElement base = m_validationContext.findElement(group);
DefinitionItem basedef = ((GlobalExtension)base.getExtension()).getDefinition();
mapping.setExtendsName(basedef.getGenerateClass().getFullName());
}
} else {
// abstract mapping for type definition or group
mapping.setAbstract(true);
QName qname = definition.getQName();
mapping.setTypeQName(qname);
String uri = qname.getUri();
if (uri != null) {
m_bindingDirectory.addTypeNameReference(holder, uri, schema);
}
}
// add the mapping to binding and set on class
holder.addMapping(mapping);
((StructureClassHolder)clas).setBinding(mapping);
DefinitionItem elementdef = (DefinitionItem)typeinst.get(definition);
if (elementdef != null) {
// create mapping for element name linked to type
ElementElement element = (ElementElement)elementdef.getSchemaComponent();
SchemaElement elschema = element.getSchema();
MappingElementBase elmapping = new MappingElement();
elmapping.setClassName(clas.getBindingName());
elmapping.setAbstract(element.isAbstract());
// handle linking to substitution group head using extends mapping
QName group = element.getSubstitutionGroup();
if (group != null) {
ElementElement base = m_validationContext.findElement(group);
DefinitionItem basedef = ((GlobalExtension)base.getExtension()).getDefinition();
elmapping.setExtendsName(basedef.getGenerateClass().getFullName());
}
// create single structure child invoking the type mapping
holder = m_bindingDirectory.getRequiredBinding(elschema);
setName(element.getEffectiveQName(), elmapping, holder);
StructureElement struct = new StructureElement();
QName qname = mapping.getTypeQName();
String uri = qname.getUri();
if (uri != null) {
m_bindingDirectory.addTypeNameReference(holder, uri, schema);
}
struct.setMapAsQName(qname);
elmapping.addChild(struct);
holder.addMapping(elmapping);
}
}
// set the definition for the class (and create any required secondary classes)
clas.buildDataStructure(definition, holder);
}
}
/**
* Initialize the bindings to be generated. This configures the binding directory, then creates the required
* bindings and sets their prefixes.
*/
private void initializeBindings() {
m_bindingDirectory = new BindingOrganizer(false, false, false, true, true, true);
Map namebindings = new HashMap();
Map nsbindings = new HashMap();
for (Iterator iter = m_validationContext.iterateSchemas(); iter.hasNext();) {
// check binding handling for schema
SchemaElement schema = (SchemaElement)iter.next();
SchemaExtension exten = (SchemaExtension)schema.getExtension();
String uri = schema.getEffectiveNamespace();
String prefix = exten.getPrefix();
BindingHolder holder;
String name = exten.getBindingFileName();
boolean dflt = schema.isElementQualifiedDefault() || uri == null;
if (name != null) {
// specific binding name, create the binding or link to existing
holder = (BindingHolder)namebindings.get(name);
if (holder == null) {
holder = m_bindingDirectory.getBinding(schema);
if (holder == null) {
holder = m_bindingDirectory.addBinding(schema, uri, prefix, dflt);
}
holder.setFileName(name);
namebindings.put(name, holder);
} else {
m_bindingDirectory.addBindingObject(schema, holder);
}
} else if (exten.isForceBinding()) {
// binding needed for this schema, create it
holder = m_bindingDirectory.addBinding(schema, uri, prefix, dflt);
} else {
// need binding for namespace, create or link to existing
holder = (BindingHolder)nsbindings.get(uri);
if (holder == null) {
holder = m_bindingDirectory.addBinding(schema, uri, prefix, dflt);
nsbindings.put(uri, holder);
} else {
m_bindingDirectory.addBindingObject(schema, holder);
}
}
}
}
/**
* Generate the data model. This first builds a representation of all the data items from the schema definitions,
* then determines which items can be inlined and which need separate class representations, and finally builds the
* actual data model class and binding definitions.
*
* @param verbose verbose output flag
* @param usenns no-namespace namespace used flag
* @param typemap map from qualified name of type (or attributeGroup, or group) to pregenerated mapping definition
* @param elemmap map from qualified name of element to pregenerated mapping definition
* @return root package for binding
*/
public String buildDataModel(boolean verbose, boolean usenns, Map elemmap, Map typemap) {
// build the item structure for each definition and link to pregenerated classes
ArrayList items = buildItemStructures();
for (int i = 0; i < items.size(); i++) {
DefinitionItem definition = (DefinitionItem)items.get(i);
QName qname = definition.getQName();
TypeData clas = null;
switch (definition.getSchemaComponent().type()) {
case SchemaBase.ATTRIBUTEGROUP_TYPE:
case SchemaBase.COMPLEXTYPE_TYPE:
case SchemaBase.GROUP_TYPE:
case SchemaBase.SIMPLETYPE_TYPE:
{
clas = (TypeData)typemap.get(qname);
break;
}
case SchemaBase.ELEMENT_TYPE:
{
clas = (TypeData)elemmap.get(qname);
break;
}
}
if (clas != null) {
definition.setGenerateClass(clas);
definition.setInlineBlocked(true);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Found class " + clas.getFullName() + " for " + qname);
}
}
}
// convert elements based on types and compact all items
Map typeinstmap = convertTypeIsomorphicElements(items);
for (int i = 0; i < items.size(); i++) {
compactGroups((DefinitionItem)items.get(i));
}
// inline references where appropriate
initializeBindings();
ArrayList defs = inlineReferences(items);
// assign class and property names for all items
for (int i = 0; i < defs.size(); i++) {
DefinitionItem def = (DefinitionItem)defs.get(i);
compactGroups(def);
assignNames(null, def, true);
if (s_logger.isInfoEnabled()) {
s_logger.info("After assigning names for "
+ SchemaUtils.describeComponent(def.getSchemaComponent()) + ":\n" + def.describe());
}
}
// convert extension references for all global type definitions
for (int i = 0; i < defs.size(); i++) {
((DefinitionItem)defs.get(i)).convertTypeReference();
}
// classify all the items by form of content
for (int i = 0; i < items.size(); i++) {
DefinitionItem def = (DefinitionItem)items.get(i);
def.classifyContent();
if (s_logger.isInfoEnabled()) {
s_logger.info("After inlining and classification for " +
SchemaUtils.describeComponent(def.getSchemaComponent())
+ ":\n" + def.describe());
}
}
// build the actual class and binding structure
setDefaultPrefixes(m_validationContext.iterateSchemas());
buildClassesAndBindings(defs, typeinstmap);
// build the actual classes
AST ast = AST.newAST(AST.JLS3);
ArrayList packs = m_packageDirectory.getPackages();
PackageHolder rootpack = null;
for (int i = 0; i < packs.size(); i++) {
PackageHolder pack = ((PackageHolder)packs.get(i));
if (pack.getClassCount() > 0) {
if (rootpack == null) {
PackageHolder scan = pack;
while (scan != null) {
if (scan.getClassCount() > 0 || scan.getSubpackageCount() > 1) {
rootpack = scan;
}
scan = scan.getParent();
}
}
pack.generate(verbose, ast, m_bindingDirectory);
}
}
// return the root package name
if (rootpack == null) {
rootpack = m_packageDirectory.getPackage("");
}
return rootpack.getName();
}
/**
* Get the binding directory.
*
* @return directory
*/
public BindingOrganizer getBindingDirectory() {
return m_bindingDirectory;
}
/**
* Write the binding definitions file(s). This method can only be used after
* {@link #buildDataModel(boolean, boolean, Map, Map)} is called.
*
* @param name root binding definition file name (use customization, or default, if null)
* @param pack target package for binding (null if unspecified)
* @param pregens pregenerated bindings to be included in root binding
* @param handler validation error and code generation problem handler
* @throws JiBXException
* @throws IOException
*/
public void writeBindings(String name, String pack, List pregens, ProblemHandler handler)
throws JiBXException, IOException {
if (name == null) {
name = m_global.getBindingFileName();
if (name == null) {
name = "binding.xml";
}
}
m_rootHolder = m_bindingDirectory.configureFiles(name, pack, pregens);
IClassLocator iloc = new DummyClassLocator();
org.jibx.binding.model.ValidationContext vctx = new org.jibx.binding.model.ValidationContext(iloc);
if (m_bindingDirectory.validateBindings(m_rootHolder, m_targetDir, vctx)) {
m_bindingDirectory.writeBindings(m_targetDir);
} else {
reportBindingProblems(vctx, handler);
throw new JiBXException("Terminating due to errors in bindings");
}
}
/**
* Get the root binding definition. This is only allowed after the call to
* {@link #writeBindings(String, String, List, ProblemHandler)}.
*
* @return root binding element
*/
public BindingElement getRootBinding() {
return m_rootHolder.getBinding();
}
/**
* Add the schemas specified by customizations to the set to be loaded.
*
* @param base root URL for schemas
* @param dir root directory for schemas
* @param custom schema set customization
* @param fileset set of schema files to be loaded
* @throws MalformedURLException
*/
/* private static void addCustomizedSchemas(URL base, File dir, SchemasetCustom custom, InsertionOrderedSet fileset)
throws MalformedURLException {
// first check for name match patterns supplied
String[] names = custom.getNames();
if (names != null) {
for (int i = 0; i < names.length; i++) {
SchemaNameFilter filter = new SchemaNameFilter();
String name = names[i];
filter.setPattern(name);
s_logger.debug("Matching file names to schemaset pattern '" + name + '\'');
String[] matches = dir.list(filter);
for (int j = 0; j < matches.length; j++) {
String match = matches[j];
fileset.add(new UrlResolver(match, new URL(base, match)));
s_logger.debug("Added schema from schemaset pattern match: " + match);
}
}
}
// next check all child customizations
LazyList childs = custom.getChildren();
for (int i = 0; i < childs.size(); i++) {
Object child = childs.get(i);
if (child instanceof SchemaCustom) {
String name = ((SchemaCustom)child).getName();
if (name != null) {
try {
fileset.add(new UrlResolver(name, new URL(base, name)));
s_logger.debug("Added schema from customizations: " + name);
} catch (MalformedURLException e) {
System.out.println("Error adding schema from customizations: " + name);
}
}
} else if (child instanceof SchemasetCustom) {
addCustomizedSchemas(base, dir, (SchemasetCustom)child, fileset);
}
}
}
*/
/**
* Get the package directory used for code generation.
*
* @return directory
*/
public PackageOrganizer getPackageDirectory() {
return m_packageDirectory;
}
/**
* Generate code from a list of schemas.
*
* @param verbose verbose output flag
* @param usens namespace to be used when no schemas with namespaces are being generated (null if not
* specified)
* @param dfltpkg default package for no-namespace schemas (null if not specified)
* @param bindname name for root binding (null if not specified)
* @param fileset list of resolvers for schemas to be generated
* @param inclpaths list of paths for bindings to be used for matching schema definitions (empty if none)
* @param model file to be used for dumping generated data model (null if none)
* @param handler validation error and code generation problem handler
* @return true if successful, false if failure
* @throws JiBXException
* @throws IOException
*/
public boolean generate(boolean verbose, String usens, String dfltpkg, String bindname, List fileset,
List inclpaths, File model, ProblemHandler handler) throws JiBXException, IOException {
// load the full set of schemas
SchemaElement[] schemas = ValidationUtils.load(fileset, usens, m_validationContext);
if (!m_validationContext.reportProblems(handler)) {
if (dfltpkg == null) {
dfltpkg = "dflt";
}
if (customizeSchemas(dfltpkg, handler)) {
// report on schemas loaded
StringBuffer buff = new StringBuffer();
buff.append("Loaded and validated " + fileset.size() + " specified schema(s)");
int refcount = m_validationContext.getSchemaCount() - fileset.size();
if (refcount > 0) {
buff.append(" and " + refcount + " referenced schema(s)");
}
if (verbose) {
buff.append(':');
handler.report(buff.toString());
listSchemas(schemas, m_validationContext, handler);
} else {
handler.report(buff.toString());
}
// apply the schema customizations and revalidate modified schema
applyAndNormalize();
pruneDefinitions();
ValidationUtils.validateSchemas(schemas, m_validationContext);
if (!m_validationContext.reportProblems(handler)) {
// load any precompiled bindings
Map elemmap = new HashMap();
Map typemap = new HashMap();
List includes = new ArrayList();
boolean usenns = false;
for (Iterator iter = inclpaths.iterator(); iter.hasNext();) {
String path = (String)iter.next();
URL url;
File file = null;
if (ClasspathUrlExtender.isClasspathUrl(path)) {
url = ClasspathUrlExtender.buildURL(null, path);
} else {
file = new File(path);
url = file.toURI().toURL();
}
try {
BindingElement binding = processPregeneratedBinding(url, elemmap, typemap, handler);
if (!usenns) {
usenns = checkNoNamespace(binding);
}
try {
org.jibx.binding.model.IncludeElement include =
new org.jibx.binding.model.IncludeElement();
if (file == null) {
include.setIncludePath(path);
} else {
include.setIncludePath(relativeFilePath(m_targetDir, file));
}
include.setPrecompiled(true);
includes.add(include);
} catch (IOException e) {
handler.terminate("Error processing path " + path, e);
return false;
}
} catch (IOException e) {
handler.terminate("Pregenerated binding not found with path: " + path);
return false;
}
}
// generate code and bindings, using any existing bindings supplied
buildDataModel(verbose, usenns, elemmap, typemap);
List packages = m_packageDirectory.getPackages();
PackageHolder top = null;
for (Iterator iter = packages.iterator(); iter.hasNext();) {
PackageHolder holder = (PackageHolder)iter.next();
if (holder.getClassCount() > 0) {
if (top == null) {
top = holder;
} else {
// find common parent package of all packages so far processed
outer: while (true) {
PackageHolder scan = holder;
while (true) {
if (scan == top) {
break outer;
} else if (scan.getName().length() < top.getName().length()) {
top = top.getParent();
break;
} else {
scan = scan.getParent();
}
}
}
}
}
}
String rootpack = top == null ? null : top.getName();
writeBindings(bindname, rootpack, includes, handler);
// print the total number of classes generated
listGeneratedPackages(packages, handler);
// check if prior data model dump file provided for comparison
if (model != null) {
if (model.exists()) {
// read the data model file
BufferedReader reader = new BufferedReader(new FileReader(model));
StringObjectPair[] image = DataModelUtils.readImage(reader);
String diff = DataModelUtils.imageDiff(image, DataModelUtils.getImage(m_packageDirectory));
if (diff == null) {
handler.report("No difference found from data model file " + model.getPath());
} else {
handler.report(diff);
}
} else {
handler.report("Difference data model file " + model.getPath() + " not found");
}
}
// check if dump file to be output
if (model != null) {
// delete the file if it already exists
if (model.exists()) {
model.delete();
}
model.createNewFile();
// now print out the class details by package
BufferedWriter writer = new BufferedWriter(new FileWriter(model));
DataModelUtils.writeImage(m_packageDirectory, writer);
writer.close();
}
} else {
handler.terminate("Terminating due to errors in normalized schemas - please report the problem");
return false;
}
} else {
handler.terminate("Terminating due to errors in customized schemas");
return false;
}
} else {
handler.terminate("Terminating due to errors in input schemas");
return false;
}
return true;
}
/**
* List the schemas in use.
*
* @param schemas
* @param vctx
* @param handler
*/
private static void listSchemas(SchemaElement[] schemas, ValidationContext vctx, ProblemHandler handler) {
Set topset = new HashSet();
for (int i = 0; i < schemas.length; i++) {
SchemaElement schema = schemas[i];
topset.add(schema);
handler.report(" " + "top-level schema " + schema.getResolver().getName());
}
for (Iterator iter = vctx.iterateSchemas(); iter.hasNext();) {
SchemaElement schema = (SchemaElement)iter.next();
if (!topset.contains(schema)) {
handler.report(" " + "referenced schema " + schema.getResolver().getName());
}
}
}
/**
* List the number of classes in each package, and the totals.
*
* @param packages
* @param handler
*/
private static void listGeneratedPackages(List packages, ProblemHandler handler) {
int top = 0;
int total = 0;
StringBuffer buff = new StringBuffer();
for (Iterator iter = packages.iterator(); iter.hasNext();) {
PackageHolder hold = (PackageHolder)iter.next();
int count = hold.getClassCount();
if (count > 0) {
int topcount = hold.getTopClassCount();
top += topcount;
buff.setLength(0);
buff.append("Generated " + topcount + " top-level classes ");
if (count != topcount) {
buff.append("(plus " + (count-topcount) + " inner classes) ");
}
buff.append("in package " + hold.getName());
handler.report(buff.toString());
total += count;
}
}
if (total == top) {
handler.report("Total classes in model: " + top);
} else {
handler.report("Total top-level classes in model: " + top);
handler.report("Total classes (including inner classes) in model: " + total);
}
}
/**
* Build class data for pregenerated class.
*
* @param cname class name
* @param simple simple value flag
* @return data
*/
private static TypeData buildClassData(String cname, boolean simple) {
String bname = cname;
String fname = bname.replace('$', '.');
return new TypeData(fname, bname, true, simple);
}
/**
* Accumulate all format and mapping definitions, including those found in included bindings. For each abstract
* mapping or named format found, the type name is associated with the class data in the type map; for each concrete
* mapping found, the element name (and namespace) is associated with the class data in the element map. Included
* bindings are handled with recursive calls.
*
* @param binding binding definition root
* @param elemmap map from element qualified name to class data
* @param typemap map from type qualified name to class data
*/
private static void accumulateBindingDefinitions(BindingElement binding, Map elemmap, Map typemap) {
ArrayList childs = binding.topChildren();
for (int i = 0; i < childs.size(); i++) {
ElementBase element = (ElementBase)childs.get(i);
if (element.type() == ElementBase.INCLUDE_ELEMENT) {
// use recursive call to add nested definitions in included binding
BindingElement inclbinding = ((org.jibx.binding.model.IncludeElement)element).getBinding();
if (inclbinding != null) {
accumulateBindingDefinitions(inclbinding, elemmap,
typemap);
}
} else if (element.type() == ElementBase.MAPPING_ELEMENT) {
// handle mapping as type if abstract with type name, or as element if concrete
MappingElementBase mapping = (MappingElementBase)element;
String cname = mapping.getClassName();
TypeData data = buildClassData(cname, false);
if (mapping.isAbstract()) {
QName qname = mapping.getTypeQName();
if (qname != null) {
typemap.put(qname, data);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Added class " + cname + " for type " + qname);
}
}
} else {
QName qname = new QName(mapping.getNamespace().getUri(), mapping.getName());
elemmap.put(qname, data);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Added class " + cname + " for element " + qname);
}
}
} else if (element.type() == ElementBase.FORMAT_ELEMENT) {
// add named format as simple type definition
FormatElement format = (FormatElement)element;
String name = format.getTypeName();
if (name != null) {
TypeData data = buildClassData(name, true);
typemap.put(format.getQName(), data);
}
}
}
}
/**
* Load and validate binding and process all format and mapping definitions, including those in included bindings.
*
* @param url binding definition path
* @param elemmap map from element qualified name to class data
* @param typemap map from type qualified name to class data
* @param handler validation error and problem handler
* @return binding
* @throws JiBXException
* @throws IOException
*/
public static BindingElement processPregeneratedBinding(URL url, Map elemmap, Map typemap, ProblemHandler handler)
throws JiBXException, IOException {
// get binding definition file name from path
String name = "";
String path = url.getPath();
if (path != null) {
name = path;
int split = Math.max(name.lastIndexOf('/'), name.lastIndexOf('\\'));
if (split > 0) {
name = name.substring(split+1);
}
split = name.lastIndexOf('.');
name = name.substring(0, split);
}
// construct object model for binding
org.jibx.binding.model.ValidationContext vctx =
new org.jibx.binding.model.ValidationContext(new DummyClassLocator());
BindingElement binding = BindingElement.readBinding(url.openStream(), name, null, true,
vctx);
binding.setBaseUrl(url);
vctx.setBindingRoot(binding);
// validate the binding definition
binding.runValidation(vctx);
// list validation errors
if (vctx.getProblems().size() > 0) {
reportBindingProblems(vctx, handler);
if (vctx.getErrorCount() > 0 || vctx.getFatalCount() > 0) {
throw new JiBXException("Errors in binding");
}
}
// add all the mapping and format definitions in binding to qualified name maps
accumulateBindingDefinitions(binding, elemmap, typemap);
return binding;
}
/**
* Report problems found in binding.
*
* @param vctx
* @param handler
*/
private static void reportBindingProblems(org.jibx.binding.model.ValidationContext vctx, ProblemHandler handler) {
StringBuffer buff = new StringBuffer();
ArrayList problems = vctx.getProblems();
for (int i = 0; i < problems.size(); i++) {
org.jibx.binding.model.ValidationProblem prob =
(org.jibx.binding.model.ValidationProblem)problems.get(i);
buff.setLength(0);
buff.append(prob.getSeverity() >= org.jibx.binding.model.ValidationProblem.ERROR_LEVEL ?
"Error: " : "Warning: ");
buff.append(prob.getDescription());
handler.report(buff.toString());
}
}
/**
* Find the steps in the canonical path to a file.
*
* @param file
* @return steps
* @throws IOException
*/
public static List findPathSteps(File file) throws IOException {
LinkedList steps = new LinkedList();
steps.addFirst(file.getName());
File parent = file;
while ((parent = parent.getParentFile()) != null) {
steps.addFirst(parent.getName());
}
return steps;
}
/**
* Construct a relative file path.
*
* @param dir start directory for path
* @param file supplied file path
* @return relative file path
* @throws IOException
*/
public static String relativeFilePath(File dir, File file) throws IOException {
// first find any common portion of the paths
List dirsteps = findPathSteps(dir);
List filesteps = findPathSteps(file);
// scan past any common portion of the paths
Iterator diriter = dirsteps.iterator();
Iterator fileiter = filesteps.iterator();
boolean abs = dir.isAbsolute();
boolean diff = false;
String filestep = null;
while (diriter.hasNext() && fileiter.hasNext()) {
String dirstep = (String)diriter.next();
filestep = (String)fileiter.next();
if (!dirstep.equals(filestep)) {
diff = true;
break;
} else {
abs = false;
}
}
// check whether relative path can be used
if (abs) {
return file.getCanonicalPath();
} else {
// create relative path to common ancestor directory
StringBuffer buff = new StringBuffer();
if (diff) {
buff.append("..");
buff.append(File.separatorChar);
}
while (diriter.hasNext()) {
buff.append("..");
buff.append(File.separatorChar);
diriter.next();
}
// extend path to the actual file
buff.append(filestep);
while (fileiter.hasNext()) {
buff.append(File.separatorChar);
buff.append(fileiter.next());
}
return buff.toString();
}
}
/**
* Check if a binding definition uses the no-namespace namespace. This calls itself to recursively check on included
* bindings.
*
* @param binding
* @return true if no-namespace namespace used, false if not
*/
public static boolean checkNoNamespace(BindingElement binding) {
loop: for (Iterator childiter = binding.topChildIterator(); childiter.hasNext();) {
ElementBase child = (ElementBase)childiter.next();
switch (child.type()) {
case ElementBase.NAMESPACE_ELEMENT:
if (((NamespaceElement)child).getPrefix() == null) {
return true;
}
break;
case ElementBase.INCLUDE_ELEMENT:
if (checkNoNamespace(((org.jibx.binding.model.IncludeElement)child).getBinding())) {
return true;
}
break;
case ElementBase.MAPPING_ELEMENT:
break loop;
}
}
return false;
}
/**
* Run the binding generation using command line parameters.
*
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
TreeWalker.setLogging(Level.ERROR);
CodeGenCommandLine parms = new CodeGenCommandLine();
if (args.length > 0 && parms.processArgs(args)) {
// build set of schemas specified on command line (including via wildcards)
final InsertionOrderedSet fileset = new InsertionOrderedSet();
URL base = parms.getSchemaRoot();
File basedir = parms.getSchemaDir();
List errors = ResourceMatcher.matchPaths(basedir, base, parms.getExtraArgs(),
new ResourceMatcher.ReportMatch() {
public void foundMatch(String path, URL url) {
fileset.add(new UrlResolver(path, url));
}
});
if (errors.size() > 0) {
for (Iterator iter = errors.iterator(); iter.hasNext();) {
s_logger.error(iter.next());
}
System.exit(2);
}
// handle code generation from schemas
ProblemMultiHandler handler = new ProblemMultiHandler();
handler.addHandler(new ProblemConsoleLister());
handler.addHandler(new ProblemLogLister(s_logger));
CodeGen inst = new CodeGen(parms.getCustomRoot(), parms.getSchemaRoot(),
parms.getGeneratePath());
inst.generate(parms.isVerbose(), parms.getUsingNamespace(), parms.getNonamespacePackage(),
parms.getBindingName(), fileset.asList(), parms.getIncludePaths(), parms.getModelFile(), handler);
} else {
if (args.length > 0) {
s_logger.error("Terminating due to command line or customization errors");
} else {
parms.printUsage();
}
System.exit(1);
}
}
/**
* Visitor to count the number of values in a definition.
*/
private static class ValueCountVisitor extends SchemaVisitor
{
// count of attributes, elements, atttributeGroup references, and group references
private int m_count;
public int getCount() {
return m_count;
}
public boolean visit(AttributeElement node) {
m_count++;
return false;
}
public boolean visit(AttributeGroupRefElement node) {
m_count++;
return false;
}
public boolean visit(ElementElement node) {
m_count++;
return false;
}
public boolean visit(GroupRefElement node) {
m_count++;
return false;
}
}
/**
* Visitor for checking element namespace usage in schema definitions. This just accumulates the set of namespaces
* used by element definitions.
*/
private static class SchemaNameVisitor extends SchemaVisitor
{
/** Set of namespace URIs used by element definitions. */
private final Set m_uris;
/**
* Constructor.
*/
public SchemaNameVisitor() {
m_uris = new HashSet();
}
/**
* Check if a single namespace is used for all element definitions.
*
* @return true if single namespace, false if not
*/
public boolean isSingleNamespace() {
return m_uris.size() <= 1;
}
/**
* Check if the no-namespace namespace is used by one or more elements.
*
* @return true if no-namespace used, false if not
*/
public boolean isNoNamespaceUsed() {
return m_uris.contains(null);
}
/**
* Accumulate namespace used by element definition.
*
* @param node
*/
public void exit(ElementElement node) {
QName qname = node.getQName();
if (qname != null) {
m_uris.add(qname.getUri());
}
super.exit(node);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/datamodel/ 0000755 0001750 0001750 00000000000 11300355302 024435 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/SourceBuilder.java 0000644 0001750 0001750 00000036530 11415072370 026134 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.ToolFactory;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.ImportDeclaration;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jdt.core.dom.PackageDeclaration;
import org.eclipse.jdt.core.dom.ParameterizedType;
import org.eclipse.jdt.core.dom.PrimitiveType;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.PrimitiveType.Code;
import org.eclipse.jdt.core.formatter.CodeFormatter;
import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
import org.eclipse.jface.text.Document;
import org.eclipse.text.edits.DeleteEdit;
import org.eclipse.text.edits.InsertEdit;
import org.eclipse.text.edits.ReplaceEdit;
import org.eclipse.text.edits.TextEdit;
import org.eclipse.text.edits.TextEditVisitor;
/**
* Abstract syntax tree builder. This wraps the AST with convenience methods and added control information.
*/
public class SourceBuilder
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(SourceBuilder.class.getName());
/** Map from primitive type name to type code. */
private static final Map s_primitiveTypeCodes;
static {
s_primitiveTypeCodes = new HashMap();
s_primitiveTypeCodes.put("boolean", PrimitiveType.BOOLEAN);
s_primitiveTypeCodes.put("byte", PrimitiveType.BYTE);
s_primitiveTypeCodes.put("char", PrimitiveType.CHAR);
s_primitiveTypeCodes.put("double", PrimitiveType.DOUBLE);
s_primitiveTypeCodes.put("float", PrimitiveType.FLOAT);
s_primitiveTypeCodes.put("int", PrimitiveType.INT);
s_primitiveTypeCodes.put("long", PrimitiveType.LONG);
s_primitiveTypeCodes.put("short", PrimitiveType.SHORT);
s_primitiveTypeCodes.put("void", PrimitiveType.VOID);
}
/** Actual AST instance. */
private final AST m_ast;
/** Package containing this source. */
private final PackageHolder m_package;
/** Name of this source. */
private final String m_name;
/** Compilation unit. */
private final CompilationUnit m_compilationUnit;
/** Tracker for imports. */
protected final ImportsTracker m_importsTracker;
/** Builders for main classes in file. */
private ArrayList m_classes;
/**
* Constructor.
*
* @param ast
* @param pack
* @param name
* @param imports
*/
public SourceBuilder(AST ast, PackageHolder pack, String name, ImportsTracker imports) {
// initialize basic parameters
m_ast = ast;
m_package = pack;
m_name = name;
m_importsTracker = imports;
m_classes = new ArrayList();
// create file in appropriate package
m_compilationUnit = ast.newCompilationUnit();
String pname = pack.getName();
if (pname.length() > 0) {
PackageDeclaration packageDeclaration = ast.newPackageDeclaration();
packageDeclaration.setName(ast.newName(pname));
m_compilationUnit.setPackage(packageDeclaration);
}
}
/**
* AST access for related classes.
*
* @return AST
*/
AST getAST() {
return m_ast;
}
/**
* Get the name of the package containing this source file.
*
* @return name
*/
public String getPackageName() {
return m_package.getName();
}
/**
* Create a type declaration.
*
* @param cname class name
* @param isenum Java 5 enum class flag
* @return type declaration
*/
private AbstractTypeDeclaration createClass(String cname, boolean isenum) {
AbstractTypeDeclaration abstype;
if (isenum) {
abstype = m_ast.newEnumDeclaration();
} else {
TypeDeclaration type = m_ast.newTypeDeclaration();
type.setInterface(false);
abstype = type;
}
abstype.modifiers().add(m_ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));
abstype.setName(m_ast.newSimpleName(cname));
return abstype;
}
/**
* Add a new main class to the file.
*
* @param cname class name
* @param isenum Java 5 enum class flag
* @return builder
*/
public ClassBuilder newMainClass(String cname, boolean isenum) {
AbstractTypeDeclaration decl = createClass(cname, isenum);
m_compilationUnit.types().add(decl);
ClassBuilder builder = new ClassBuilder(decl, this);
m_classes.add(builder);
return builder;
}
/**
* Add a new inner class to the file.
*
* @param cname class name
* @param outer containing class builder
* @param isenum Java 5 enum class flag
* @return builder
*/
public ClassBuilder newInnerClass(String cname, ClassBuilder outer, boolean isenum) {
AbstractTypeDeclaration decl = createClass(cname, isenum);
decl.modifiers().add(m_ast.newModifier(Modifier.ModifierKeyword.STATIC_KEYWORD));
// type.superInterfaceTypes().add(createType("java.io.Serializable"));
return new ClassBuilder(decl, outer);
}
/**
* Create type name.
*
* @param type fully-qualified type name
* @return name
*/
protected Name createTypeName(String type) {
String name = m_importsTracker.getName(type);
if (name.indexOf('.') > 0) {
return m_ast.newName(name);
} else {
return m_ast.newSimpleName(name);
}
}
/**
* Create type definition. This uses the supplied type name, which may include array suffixes and/or type
* parameters, to construct the actual type definition.
*
* @param type fully qualified type name, or primitive type name
* @return constructed typed definition
*/
public Type createType(String type) {
// start by stripping off any array suffixes
int arraydepth = 0;
while (type.endsWith("[]")) {
arraydepth++;
type = type.substring(0, type.length()-2);
}
// next strip off any type parameters
String typeparms = null;
int split = type.indexOf('<');
if (split > 0) {
typeparms = type.substring(split+1, type.length()-1);
type = type.substring(0, split);
}
// handle the basic type creation
Type tdef;
Code code = (Code)s_primitiveTypeCodes.get(type);
if (code == null) {
tdef = getAST().newSimpleType(createTypeName(type));
} else {
tdef = getAST().newPrimitiveType(code);
}
// add type parameter information
if (typeparms != null) {
ParameterizedType ptype = getAST().newParameterizedType(tdef);
while ((split = typeparms.indexOf(',')) > 0) {
ptype.typeArguments().add(createType(typeparms.substring(0, split)));
typeparms = typeparms.substring(split+1);
}
ptype.typeArguments().add(createType(typeparms));
tdef = ptype;
}
// add any layers of arrays
if (arraydepth > 0) {
tdef = getAST().newArrayType(tdef, arraydepth);
}
return tdef;
}
/**
* Create a parameterized type.
*
* @param type fully qualified type name
* @param param fully qualified parameter type name
* @return type
*/
public Type createParameterizedType(String type, String param) {
ParameterizedType ptype = getAST().newParameterizedType(createType(type));
ptype.typeArguments().add(createType(param));
return ptype;
}
/**
* Generate the actual source file.
*
* @param verbose
*/
public void finish(boolean verbose) {
// finish building all the classes in this source
long start = System.currentTimeMillis();
for (int i = 0; i < m_classes.size(); i++) {
ClassBuilder builder = (ClassBuilder)m_classes.get(i);
builder.finish();
}
// add all imports to source
List imports = m_importsTracker.freeze(m_name);
for (Iterator iter = imports.iterator(); iter.hasNext();) {
String type = (String)iter.next();
ImportDeclaration imp = m_ast.newImportDeclaration();
imp.setName(m_ast.newName(type));
m_compilationUnit.imports().add(imp);
}
// convert generated AST to text document
Map options = new HashMap();
options.put(DefaultCodeFormatterConstants.FORMATTER_LINE_SPLIT, "80");
options.put(DefaultCodeFormatterConstants.FORMATTER_COMMENT_LINE_LENGTH, "80");
options.put(DefaultCodeFormatterConstants.FORMATTER_COMMENT_FORMAT_SOURCE, "true");
options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, JavaCore.SPACE);
options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, "4");
options.put(DefaultCodeFormatterConstants.FORMATTER_BLANK_LINES_AFTER_PACKAGE, "1");
options.put(DefaultCodeFormatterConstants.FORMATTER_BLANK_LINES_AFTER_IMPORTS, "1");
options.put(DefaultCodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_PACKAGE, "1");
options.put(DefaultCodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_IMPORTS, "1");
options.put(DefaultCodeFormatterConstants.FORMATTER_BLANK_LINES_BEFORE_METHOD, "1");
options.put(DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION,
DefaultCodeFormatterConstants.NEXT_LINE);
options.put(DefaultCodeFormatterConstants.FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_TYPE_DECLARATION,
DefaultCodeFormatterConstants.createAlignmentValue(false, DefaultCodeFormatterConstants.WRAP_COMPACT,
DefaultCodeFormatterConstants.INDENT_BY_ONE));
options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_5);
options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_5);
options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_5);
Document doc = new Document(m_compilationUnit.toString());
CodeFormatter fmtr = ToolFactory.createCodeFormatter(options);
String text = doc.get();
TextEdit edits = fmtr.format(CodeFormatter.K_COMPILATION_UNIT, text, 0, text.length(), 0, null);
File gendir = m_package.getGenerateDirectory();
if (gendir != null) {
try {
File file = new File(gendir, m_name + ".java");
FileWriter fwrit = new FileWriter(file);
WriterVisitor visitor = new WriterVisitor(text, fwrit);
edits.accept(visitor);
visitor.finish();
fwrit.flush();
fwrit.close();
s_logger.info("Generated class file " + file.getCanonicalPath() + " (writing AST took " + (System.currentTimeMillis()-start) + " ms.)");
} catch (IOException e) {
throw new IllegalStateException("Error in source generation: " + e.getMessage());
}
}
}
/**
* Visitor to apply edits. This is used to avoid the overhead of standard document processing of the edits generated
* by formatting.
*/
private static class WriterVisitor extends TextEditVisitor
{
private final String m_base;
private final Writer m_writer;
private int m_offset;
/**
* Constructor.
*
* @param base
* @param writer
*/
public WriterVisitor(String base, Writer writer) {
m_base = base;
m_writer = writer;
}
private void skip(int offset) {
if (offset > m_offset) {
m_offset = offset;
} else if (offset < m_offset) {
throw new IllegalStateException();
}
}
private void copy(int offset) {
if (offset > m_offset) {
try {
m_writer.write(m_base, m_offset, offset-m_offset);
} catch (IOException e) {
throw new RuntimeException("Error writing to file", e);
}
m_offset = offset;
} else if (offset < m_offset) {
throw new IllegalStateException();
}
}
public boolean visit(DeleteEdit edit) {
copy(edit.getOffset());
skip(edit.getOffset()+edit.getLength());
return super.visit(edit);
}
public boolean visit(InsertEdit edit) {
copy(edit.getOffset());
try {
m_writer.write(edit.getText());
} catch (IOException e) {
throw new RuntimeException("Error writing to file", e);
}
return super.visit(edit);
}
public boolean visit(ReplaceEdit edit) {
copy(edit.getOffset());
skip(edit.getOffset()+edit.getLength());
try {
m_writer.write(edit.getText());
} catch (IOException e) {
throw new RuntimeException("Error writing to file", e);
}
return super.visit(edit);
}
/**
* Finish writing output. This needs to be called after visiting the tree, to catch any final bits at the end.
*/
public void finish() {
copy(m_base.length());
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/ValueItem.java 0000644 0001750 0001750 00000013322 11031442754 025253 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.jibx.runtime.QName;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.elements.AnnotatedBase;
/**
* Information for an item of a predefined type to be included in code generated from schema.
*
* @author Dennis M. Sosnoski
*/
public class ValueItem extends Item
{
/** Predefined type reference. */
private final JavaType m_type;
/** Original schema type. */
private final QName m_schemaType;
/** Attribute data present flag. */
private boolean m_attributePresent;
/** Element data present flag. */
private boolean m_elementPresent;
/** Character data content data present flag. */
private boolean m_contentPresent;
/**
* Copy constructor. This creates a copy with a new parent.
*
* @param original
* @param ref reference (for overrides to copy; null if none)
* @param parent
*/
private ValueItem(ValueItem original, Item ref, GroupItem parent) {
super(original, ref, original.getComponentExtension(), parent);
if (isOptional() || isCollection()) {
throw new IllegalStateException("Internal error - value item should never be repeating or optional");
}
m_type = original.m_type;
m_schemaType = original.m_schemaType;
}
/**
* Constructor.
*
* @param comp schema component extension
* @param type schema type name
* @param ref schema type equivalent (null if not appropriate)
* @param parent containing structure (null if a top-level structure)
*/
/*package*/ ValueItem(AnnotatedBase comp, QName type, JavaType ref, GroupItem parent) {
super(comp, parent);
m_type = ref;
m_schemaType = type;
}
/**
* Get the simple type for this value.
*
* @return type
*/
public JavaType getType() {
return m_type;
}
/**
* Get schema type name.
*
* @return name
*/
public QName getSchemaType() {
return m_schemaType;
}
/**
* Copy the item under a different parent.
*
* @param ref reference (for overrides to copy; null if none)
* @param parent
* @return copy
*/
protected Item copy(Item ref, GroupItem parent) {
return new ValueItem(this, ref, parent);
}
/**
* Build a description of the item.
*
* @param depth current nesting depth
* @param classified include classification details flag
* @return description
*/
protected String describe(int depth, boolean classified) {
StringBuffer buff = new StringBuffer(depth + 50);
buff.append(leadString(depth));
buff.append("value of type ");
buff.append(m_type.getClassName());
if (m_type.getPrimitiveName() != null) {
buff.append(" (");
buff.append(m_type.getPrimitiveName());
buff.append(")");
}
buff.append(" with value name ");
buff.append(getName());
buff.append(": ");
buff.append(SchemaUtils.describeComponent(getSchemaComponent()));
buff.append('\n');
return buff.toString();
}
/**
* Check if an attribute is part of this item. This is only true for items corresponding to attribute
* definitions, and groupings including these items which do not define an element name.
*
* @return true if attribute
*/
public boolean isAttributePresent() {
return m_attributePresent;
}
/**
* Check if a child elements is part of this item. This is true for all items corresponding to element
* definitions, and all groupings which include such an item.
*
* @return true if content
*/
public boolean isElementPresent() {
return m_elementPresent;
}
/**
* Check if character data content is part of this item. This is true for all items corresponding to
* simpleContent definitions, and all groupings which include such an item.
*
* @return true if content
*/
public boolean isContentPresent() {
return m_contentPresent;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/NameUtils.java 0000644 0001750 0001750 00000022673 11365565226 025304 0 ustar twerner twerner /*
* Copyright (c) 2006-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.util.HashSet;
/**
* Support methods for working with Java names.
*
* @author Dennis M. Sosnoski
*/
public class NameUtils
{
/** Reserved words for Java (keywords and literals). */
private static final HashSet s_reservedWords = new HashSet();
static {
// keywords
s_reservedWords.add("abstract");
s_reservedWords.add("assert");
s_reservedWords.add("boolean");
s_reservedWords.add("break");
s_reservedWords.add("byte");
s_reservedWords.add("case");
s_reservedWords.add("catch");
s_reservedWords.add("char");
s_reservedWords.add("class");
s_reservedWords.add("const");
s_reservedWords.add("continue");
s_reservedWords.add("default");
s_reservedWords.add("do");
s_reservedWords.add("double");
s_reservedWords.add("else");
s_reservedWords.add("enum");
s_reservedWords.add("extends");
s_reservedWords.add("final");
s_reservedWords.add("finally");
s_reservedWords.add("float");
s_reservedWords.add("for");
s_reservedWords.add("goto");
s_reservedWords.add("if");
s_reservedWords.add("implements");
s_reservedWords.add("import");
s_reservedWords.add("instanceof");
s_reservedWords.add("int");
s_reservedWords.add("interface");
s_reservedWords.add("long");
s_reservedWords.add("native");
s_reservedWords.add("new");
s_reservedWords.add("package");
s_reservedWords.add("private");
s_reservedWords.add("protected");
s_reservedWords.add("public");
s_reservedWords.add("return");
s_reservedWords.add("short");
s_reservedWords.add("static");
s_reservedWords.add("strictfp");
s_reservedWords.add("super");
s_reservedWords.add("switch");
s_reservedWords.add("synchronized");
s_reservedWords.add("this");
s_reservedWords.add("throw");
s_reservedWords.add("throws");
s_reservedWords.add("transient");
s_reservedWords.add("try");
s_reservedWords.add("void");
s_reservedWords.add("volatile");
s_reservedWords.add("while");
// literals
s_reservedWords.add("true");
s_reservedWords.add("false");
s_reservedWords.add("null");
}
/** Java default import class names (not exhaustive, but anything that might represent generated code conflict). */
private static final HashSet s_defaultImportClassNames = new HashSet();
static {
// interfaces
s_defaultImportClassNames.add("Appendable");
s_defaultImportClassNames.add("CharSequence");
s_defaultImportClassNames.add("Cloneable");
s_defaultImportClassNames.add("Comparable");
s_defaultImportClassNames.add("Iterable");
s_defaultImportClassNames.add("Readable");
s_defaultImportClassNames.add("Runnable");
// classes
s_defaultImportClassNames.add("Boolean");
s_defaultImportClassNames.add("Byte");
s_defaultImportClassNames.add("Character");
s_defaultImportClassNames.add("Class");
s_defaultImportClassNames.add("ClassLoader");
s_defaultImportClassNames.add("Double");
s_defaultImportClassNames.add("Enum");
s_defaultImportClassNames.add("Float");
s_defaultImportClassNames.add("Integer");
s_defaultImportClassNames.add("Long");
s_defaultImportClassNames.add("Math");
s_defaultImportClassNames.add("Number");
s_defaultImportClassNames.add("Object");
s_defaultImportClassNames.add("Package");
s_defaultImportClassNames.add("Short");
s_defaultImportClassNames.add("String");
s_defaultImportClassNames.add("StringBuffer");
s_defaultImportClassNames.add("StringBuilder");
s_defaultImportClassNames.add("System");
s_defaultImportClassNames.add("Thread");
s_defaultImportClassNames.add("Throwable");
s_defaultImportClassNames.add("Void");
// exceptions/errors
s_defaultImportClassNames.add("Exception");
s_defaultImportClassNames.add("Error");
}
/**
* Check if a name is reserved in Java.
*
* @param name
* @return is reserved
*/
public static boolean isReserved(String name) {
return s_reservedWords.contains(name);
}
/**
* Convert name if it is reserved in Java.
*
* @param name
* @return non-reserved name
*/
public static String convertReserved(String name) {
if (isReserved(name)) {
return "_" + name;
} else {
return name;
}
}
/**
* Check if a class name is a default import in Java.
*
* @param name
* @return is reserved
*/
public static boolean isDefaultImport(String name) {
return s_defaultImportClassNames.contains(name);
}
/**
* Convert a raw package name to a legal Java package name. The raw package name must be in standard package name
* form, with periods separating the individual directory components of the package name.
*
* @param raw basic package name, which may include illegal characters
* @return sanitized package name
*/
public static String sanitizePackageName(String raw) {
StringBuffer buff = new StringBuffer(raw.length());
boolean first = true;
for (int i = 0; i < raw.length();) {
char chr = buff.charAt(i);
if (first) {
if (Character.isJavaIdentifierStart(chr)) {
first = false;
i++;
} else {
buff.deleteCharAt(i);
}
} else if (chr == '.') {
first = true;
i++;
} else if (!Character.isJavaIdentifierPart(chr)) {
buff.deleteCharAt(i);
} else {
i++;
}
}
return buff.toString();
}
/**
* Convert a word to a name component. This is intended for use when composing names, as when generating access
* method names for a property. If the supplied word starts with one or more underscores, this first strips the
* the underscores. If the resulting text starts with a lower case letter this then converts that character to upper
* case. Finally, if the result either begins with a digit or is the word "Class" this prepends a leading underscore
* back on.
*
* @param word
* @return word with uppercase initial letter
*/
public static String toNameWord(String word) {
char chr;
while ((chr = word.charAt(0)) == '_' && word.length() > 1) {
word = word.substring(1);
}
if (Character.isLowerCase(chr)) {
StringBuffer buff = new StringBuffer(word);
buff.setCharAt(0, Character.toUpperCase(chr));
word = buff.toString();
}
if ("Class".equals(word)) {
return "_Class";
} else if (Character.isDigit(word.charAt(0))) {
return "_" + word;
} else {
return word;
}
}
/**
* Convert a word to a leading name component. If the supplied word starts with an uppercase letter which is not
* followed by another uppercase letter, this converts the initial uppercase to lowercase.
*
* @param word
* @return word with lowercase initial letter
*/
public static String toNameLead(String word) {
char chr = word.charAt(0);
if (Character.isUpperCase(chr) && (word.length() < 2 || Character.isLowerCase(word.charAt(1)))) {
StringBuffer buff = new StringBuffer(word);
buff.setCharAt(0, Character.toLowerCase(chr));
return buff.toString();
} else {
return word;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/IfBuilder.java 0000644 0001750 0001750 00000005607 10752422370 025235 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.IfStatement;
import org.eclipse.jdt.core.dom.Statement;
/**
* If statement builder. This wraps the AST if representation with convenience methods and added control information.
*
* @author Dennis M. Sosnoski
*/
public class IfBuilder extends StatementBuilderBase
{
/** Method invocation. */
private final IfStatement m_if;
/** "then" block of statement (automatically created). */
private BlockBuilder m_thenBlock;
/**
* Constructor.
*
* @param source
* @param expr expression
*/
public IfBuilder(ClassBuilder source, Expression expr) {
super(source);
m_if = source.getAST().newIfStatement();
m_if.setExpression(expr);
m_thenBlock = source.newBlock();
m_if.setThenStatement(m_thenBlock.getStatement());
}
/**
* Get the statement.
*
* @return statement
*/
Statement getStatement() {
return m_if;
}
/**
* Get the "then" conditional block.
*
* @return block
*/
public BlockBuilder getThen() {
return m_thenBlock;
}
/**
* Set the "else" conditional statement.
*
* @param stmt
*/
public void setElse(StatementBuilderBase stmt) {
m_if.setElseStatement(stmt.getStatement());
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/RefactoryCommandLine.java 0000644 0001750 0001750 00000004522 11075734010 027424 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
/**
* Command line processing specifically for the {@link Refactory} class.
*
* @author Dennis M. Sosnoski
*/
public class RefactoryCommandLine extends SchemaCommandLineBase
{
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.CustomizationCommandLineBase#printUsage()
*/
public void printUsage() {
System.out.println("\nUsage: java org.jibx.schema.codegen.custom.Refactory "
+ "[options] schema1 schema2 ...\nwhere options are:");
String[] usages = getUsageLines();
for (int i = 0; i < usages.length; i++) {
System.out.println(usages[i]);
}
System.out.println("The schema# files are different schemas to be included in "
+ "the refactoring\n(references from these schemas will also be included).\n");
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/CodeGenCommandLine.java 0000644 0001750 0001750 00000026240 11422465740 027002 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.jibx.custom.CustomizationCommandLineBase;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.codegen.custom.SchemasetCustom;
import org.jibx.schema.validation.ProblemConsoleLister;
import org.jibx.schema.validation.ProblemLogLister;
import org.jibx.schema.validation.ProblemMultiHandler;
import org.jibx.util.ReflectionUtilities;
/**
* Command line processing specifically for the {@link CodeGen} class.
*
* @author Dennis M. Sosnoski
*/
public class CodeGenCommandLine extends CustomizationCommandLineBase
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(CodeGenCommandLine.class.getName());
/** Ordered array of extra usage lines. */
private static final String[] EXTRA_USAGE_LINES = new String[] {
" -b name generated root binding name",
" -d file data model class structure for difference comparison",
" -i path,... include existing bindings (one or more), and use for matching\n" +
" schema global definitions",
" -m file file for dumping the generated data model class structure",
" -n pack default package for no-namespace schema definitions",
" -p pack default package for all schema definitions",
" -s path schema root directory path",
" -u uri namespace applied for code generation when no-namespaced schemas\n" +
" are found"};
/** Default package for no-namespace schemas. */
private String m_nonamespacePackage;
/** Default package for all schemas. */
private String m_defaultPackage;
/** Schema root path. */
private String m_rootPath;
/** Name used for root binding. */
private String m_bindingName;
/** Namespace to be used for no-namespace schemas generated directly. */
private String m_usingNamespace;
/** Root URL for schemas. */
private URL m_schemaRoot;
/** Root directory for schemas (null if not a file system root). */
private File m_schemaDir;
/** File for dumping the generated class structure (null if none). */
private File m_modelFile;
/** File for checking differences in generated class structure (null if none). */
private File m_differenceFile;
/** Customizations model root. */
private SchemasetCustom m_customRoot;
/** List of existing bindings to be included and used for matching schema definitions. */
private List m_includePaths;
/**
* Constructor.
*/
public CodeGenCommandLine() {
super(EXTRA_USAGE_LINES);
m_includePaths = new ArrayList();
}
/**
* Get root URL for schemas.
*
* @return directory
*/
public URL getSchemaRoot() {
return m_schemaRoot;
}
/**
* Get root directory for schemas.
*
* @return directory (null if root is not a directory)
*/
public File getSchemaDir() {
return m_schemaDir;
}
/**
* Get binding name.
*
* @return name (null if not set)
*/
public String getBindingName() {
return m_bindingName;
}
/**
* Get namespace to be used when no schemas with namespaces are being generated.
*
* @return namespace URI (null if unspecified)
*/
public String getUsingNamespace() {
return m_usingNamespace;
}
/**
* Get customizations model root.
*
* @return customizations
*/
public SchemasetCustom getCustomRoot() {
return m_customRoot;
}
/**
* Get default package for no-namespace schemas.
*
* @return package (null if not set)
*/
public String getNonamespacePackage() {
return m_nonamespacePackage;
}
/**
* Get file to be used for dumping generated data model.
*
* @return dump file (null if none)
*/
public File getModelFile() {
return m_modelFile;
}
/**
* Get file to be used for finding differences in generated data model.
*
* @return difference file (null if none)
*/
public File getDifferenceFile() {
return m_differenceFile;
}
/**
* Get the list of paths for bindings to be used for matching schema definitions.
*
* @return paths (empty if no paths specified)
*/
public List getIncludePaths() {
return m_includePaths;
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.CustomizationCommandLineBase#checkParameter(org.jibx.binding.generator.CustomizationCommandLineBase.ArgList)
*/
protected boolean checkParameter(ArgList alist) {
boolean match = true;
String arg = alist.current();
if ("-b".equalsIgnoreCase(arg)) {
m_bindingName = alist.next();
} else if ("-d".equalsIgnoreCase(arg)) {
m_differenceFile = new File(alist.next());
} else if ("-i".equalsIgnoreCase(arg)) {
String text = alist.next();
int split;
int base = 0;
while ((split = text.indexOf(',', base)) >= 0) {
m_includePaths.add(text.substring(base, split));
base = split + 1;
}
m_includePaths.add(text.substring(base));
} else if ("-m".equalsIgnoreCase(arg)) {
m_modelFile = new File(alist.next());
} else if ("-n".equalsIgnoreCase(arg)) {
m_nonamespacePackage = alist.next();
} else if ("-p".equalsIgnoreCase(arg)) {
m_defaultPackage = alist.next();
} else if ("-s".equalsIgnoreCase(arg)) {
m_rootPath = alist.next();
} else if ("-u".equalsIgnoreCase(arg)) {
m_usingNamespace = alist.next();
} else {
match = super.checkParameter(alist);
}
return match;
}
/**
* Finish processing of command line parameters. This just sets up the schema directory.
*
* @param alist
*/
protected void finishParameters(ArgList alist) {
super.finishParameters(alist);
try {
if (m_rootPath == null) {
m_schemaDir = new File(".").getCanonicalFile();
m_schemaRoot = m_schemaDir.toURI().toURL();
} else {
String path = m_rootPath;
File pathfile = new File(path).getCanonicalFile();
if (pathfile.exists()) {
if (pathfile.isDirectory()) {
m_schemaDir = pathfile;
m_schemaRoot = pathfile.toURI().toURL();
} else {
System.out.println("Schema root path '" + m_rootPath + "' must be a directory");
alist.setValid(false);
}
} else {
if (!path.endsWith("/")) {
path += '/';
}
m_schemaRoot = new URL(path);
if (m_schemaRoot.getProtocol().equals("file")) {
m_schemaDir = new File(m_schemaRoot.getPath()).getCanonicalFile();
}
}
}
} catch (MalformedURLException e) {
System.out.println("Root path '" + m_rootPath + "' not found as file and not recognized as URL");
alist.setValid(false);
} catch (IOException e) {
System.out.println("Error processing root path '" + m_rootPath + '\'');
alist.setValid(false);
}
}
/**
* Load the customizations file. This method must load the specified customizations file, or create a default
* customizations instance, of the appropriate type.
*
* @param path customization file path
* @return true if successful, false if an error
* @throws JiBXException
* @throws IOException
*/
protected boolean loadCustomizations(String path) throws JiBXException, IOException {
// load customizations and check for errors
ProblemMultiHandler handler = new ProblemMultiHandler();
handler.addHandler(new ProblemConsoleLister());
handler.addHandler(new ProblemLogLister(s_logger));
m_customRoot = SchemasetCustom.loadCustomizations(path, handler);
// set specified default package on root customization element
if (m_defaultPackage != null) {
m_customRoot.setPackage(m_defaultPackage);
}
return true;
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.CustomizationCommandLineBase#applyOverrides(Map)
*/
protected Map applyOverrides(Map overmap) {
return ReflectionUtilities.applyKeyValueMap(overmap, m_customRoot);
}
/*
* (non-Javadoc)
*
* @see org.jibx.binding.generator.CustomizationCommandLineBase#printUsage()
*/
public void printUsage() {
System.out.println("\nUsage: java org.jibx.schema.codegen.CodeGen "
+ "[options] schema1 schema2 ...\nwhere options are:");
String[] usages = getUsageLines();
for (int i = 0; i < usages.length; i++) {
System.out.println(usages[i]);
}
System.out.println("The schema# files are different schemas to be included in "
+ "the generation\n(references from these schemas will also be included).\n");
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/DefinitionItem.java 0000644 0001750 0001750 00000024030 11520374574 026274 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.apache.log4j.Logger;
import org.jibx.runtime.QName;
import org.jibx.schema.INamed;
import org.jibx.schema.IReference;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.elements.AnnotatedBase;
import org.jibx.schema.elements.AttributeGroupElement;
import org.jibx.schema.elements.GroupElement;
/**
* Information for a global definition.
*/
public class DefinitionItem extends GroupItem
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(DefinitionItem.class.getName());
/** Number of references to this definition. */
private int m_referenceCount;
/** Inlining not allowed flag. */
private boolean m_inlineBlocked;
/** Checked flag used by the code generation handling to track which definitions have already been processed. */
private boolean m_checked;
/** Tracking flag for reference seen, used during checking for inline to detect circular definitions. */
private boolean m_referenced;
/** Flag for definition structure classified. */
private boolean m_classified;
/** Type-isomorphic element flag. */
private boolean m_typeIsomorphic;
/** Qualified name for definition in binding (lazy create, null if not yet set). */
private QName m_qname;
/**
* Constructor for new top-level structure. Child structures should always be created using the containing
* structure's {@link #addGroup(AnnotatedBase)} method.
*
* @param comp schema component
*/
public DefinitionItem(AnnotatedBase comp) {
super(comp, null);
}
/**
* Constructor from group. This supports replacing an embedded group with a definition, as needed when an embedded
* group is used in multiple locations and cannot be inlined.
*
* @param group
*/
DefinitionItem(GroupItem group) {
super(group, null, null);
}
/**
* Get the number of references to this definition.
*
* @return count
*/
public int getReferenceCount() {
return m_referenceCount;
}
/**
* Count a reference to this definition.
*/
public void countReference() {
m_referenceCount++;
}
/**
* Check if inlining is blocked (due to non-singleton references).
*
* @return blocked
*/
public boolean isInlineBlocked() {
return m_inlineBlocked;
}
/**
* Set inlining blocked flag.
*
* @param blocked
*/
public void setInlineBlocked(boolean blocked) {
if (!blocked && isPregenerated()) {
throw new IllegalStateException("Internal error - inlining forbidden for pregenerated definition");
}
m_inlineBlocked = blocked;
if (s_logger.isInfoEnabled()) {
s_logger.info("Setting inlining blocked " + blocked + " for " +
SchemaUtils.describeComponent(getSchemaComponent()));
}
}
/**
* Check if definition has been processed.
*
* @return checked
*/
public boolean isChecked() {
return m_checked;
}
/**
* Set definition has been processed flag.
*
* @param checked
*/
public void setChecked(boolean checked) {
m_checked = checked;
}
/**
* Check if definition has been referenced during inline checking.
*
* @return referenced
*/
public boolean isReferenced() {
return m_referenced;
}
/**
* Set definition has been referenced during inline checking flag.
*
* @param refed
*/
public void setReferenced(boolean refed) {
m_referenced = refed;
}
/**
* Check if this is a type-isomorphic element definition. Type-isomorphic elements use the same generation class as
* the referenced type, but with a separate mapping definition.
*
* @return type-isomorphic
*/
public boolean isTypeIsomorphic() {
return m_typeIsomorphic;
}
/**
* Set the type-isomorphic element definition flag.
*
* @param iso type-isomorphic flag
*/
public void setTypeIsomorphic(boolean iso) {
m_typeIsomorphic = iso;
}
/**
* Check if definition has been pregenerated.
*
* @return pregenerated
*/
public boolean isPregenerated() {
TypeData data = super.getGenerateClass();
return data != null && data.isPregenerated();
}
/**
* Check if this definition has a class directly assigned for code generation.
*
* @return true if class directly assigned, false if not
*/
public boolean hasDirectGenerateClass() {
return super.getGenerateClass() != null;
}
/**
* Get information for class to be generated. This override of the base class implementation checks for the case of
* a definition which has been inlined, as occurs when a global element definition is the only use of a global type
* definition. If no generate class is available, this throws an exception.
*
* @return class
*/
public TypeData getGenerateClass() {
TypeData data = super.getGenerateClass();
if (data == null) {
if (isInline() || isTypeIsomorphic()) {
if (getChildCount() == 1) {
Item child = getFirstChild();
if (child instanceof ReferenceItem) {
return ((ReferenceItem)child).getDefinition().getGenerateClass();
} else {
throw new IllegalStateException("Internal error - no generate class for definition with non-reference child");
}
} else {
throw new IllegalStateException("Internal error - no generate class for definition with multiple children");
}
} else {
throw new IllegalStateException("Internal error - no generate class for non-inlined definition");
}
} else {
return data;
}
}
/**
* Get qualified name for definition in binding.
*
* @return qname
*/
public QName getQName() {
if (m_qname == null) {
AnnotatedBase comp = getSchemaComponent();
QName qname = ((INamed)comp).getQName();
if (qname == null && comp instanceof IReference) {
qname = ((IReference)comp).getRef();
}
if (comp instanceof AttributeGroupElement) {
qname = new QName(qname.getUri(), qname.getName() + "-AttributeGroup");
} else if (comp instanceof GroupElement) {
qname = new QName(qname.getUri(), qname.getName() + "-Group");
}
m_qname = qname;
}
return m_qname;
}
/**
* Classify the content of this item as attribute, element, and/or character data content. For a definition item,
* this checks if the classification has already been done, and if not flags it done and invokes the superclass
* handling.
*/
public void classifyContent() {
if (!m_classified) {
m_classified = true;
super.classifyContent();
}
}
/**
* Build a description of the item, including all nested items.
*
* @param depth current nesting depth
* @param classified include classification details flag
* @return description
*/
protected String describe(int depth, boolean classified) {
StringBuffer buff = new StringBuffer(depth + 50);
buff.append(leadString(depth));
if (isInline()) {
buff.append("inlined ");
}
if (isEnumeration()) {
buff.append("enumeration ");
}
buff.append("definition with ");
buff.append(m_referenceCount);
buff.append(" references");
if (m_inlineBlocked) {
buff.append(" (inlining blocked)");
}
buff.append(", and class name ");
buff.append(getClassName());
if (m_classified) {
buff.append(isAllOptional() ? " (all items optional)" : " (not all items optional)");
}
buff.append(": ");
buff.append(SchemaUtils.describeComponent(getSchemaComponent()));
buff.append('\n');
buff.append(nestedString(depth, classified));
return buff.toString();
}
/**
* Build a description of the definition, including all nested items.
*
* @return description
*/
protected String describe() {
return describe(0, m_classified);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/PrefixExpressionBuilder.java 0000644 0001750 0001750 00000005020 11002543776 030204 0 ustar twerner twerner /*
* Copyright (c) 2008, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.PrefixExpression;
/**
* Abstract syntax tree prefix expression builder. This adds convenience methods and control information to the base
* builder.
*/
public class PrefixExpressionBuilder extends ExpressionBuilderBase
{
/** Cast expression. */
private final PrefixExpression m_expression;
/**
* Constructor.
*
* @param source
* @param expr
* @param operand
*/
public PrefixExpressionBuilder(ClassBuilder source, PrefixExpression expr, Expression operand) {
super(source, expr);
m_expression = expr;
m_expression.setOperand(operand);
}
/**
* Add operand to expression. This class is not modifiable, so a call to this method just throws an exception.
*
* @param operand
*/
protected void addOperand(Expression operand) {
throw new IllegalStateException("Internal error: attempt to change operand expression");
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/ImportsTracker.java 0000644 0001750 0001750 00000020261 11264454442 026336 0 ustar twerner twerner /*
* Copyright (c) 2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;
/**
* Organizer for imports to a source file. This is a state-based organizer, which allows tentative imports to be
* overridden up until the point where the map from fully-qualified class names to unqualified names is constructed by
* calling {@link #getNameMap()}, then further non-conflicting imports are allowed until the final import list is
* constructed by calling {@link #freeze(String)}.
*
* @author Dennis M. Sosnoski
*/
public class ImportsTracker
{
/** Package name for classes in source. */
private final String m_packageName;
/** Set of imported classes. */
private final TreeSet m_importedTypes;
/** Map from simple names of unqualified types to full names. */
private final Map m_unqualifiedNameType;
/** Set of unqualified type full names. */
private final Map m_localTypeName;
/** Map from class names in imports set to names used (null until {@link #getNameMap()} called). */
private Map m_nameMap;
/** Further imports blocked flag. */
private boolean m_frozen;
/**
* Constructor.
*
* @param pkgname containing package name
*/
public ImportsTracker(String pkgname) {
m_packageName = pkgname;
m_importedTypes = new TreeSet();
m_unqualifiedNameType = new HashMap();
m_localTypeName = new HashMap();
}
/**
* Add local definition name to those visible in class. If the name conflicts with an import, the import is removed
* to force fully-qualified references.
*
* @param name simple class name
* @param fqname fully qualified class name
*/
public void addLocalType(String name, String fqname) {
// check for conflict with current import
String prior = (String)m_unqualifiedNameType.get(name);
if (prior != null) {
if (!fqname.equals(prior)) {
m_importedTypes.remove(prior);
}
}
// add name to unqualified types
m_unqualifiedNameType.put(name, fqname);
m_localTypeName.put(fqname, name);
}
/**
* Add import for class. If the requested import doesn't conflict with the current set it's added.
*
* @param fqname fully qualified class name
* @param force force replacement of current import
* @return true if added as import
*/
protected boolean addImport(String fqname, boolean force) {
if (m_importedTypes.contains(fqname) || m_localTypeName.containsKey(fqname)) {
return true;
} else {
// get simple class name
boolean auto = false;
String sname = fqname;
int split = sname.lastIndexOf('.');
if (split >= 0) {
sname = sname.substring(split+1);
auto = "java.lang".equals(fqname.substring(0, split));
}
// check for conflict with current import preventing addition
if (m_unqualifiedNameType.containsKey(sname) && !(split < 0 || auto || force)) {
return false;
}
// add import for type (overriding old import, if any)
m_unqualifiedNameType.put(sname, fqname);
if (split >= 0) {
// make sure still modifiable, and add to imported type set
if (m_frozen) {
throw new IllegalStateException("Internal error - attempt to add import after imports frozen");
} else {
m_importedTypes.add(fqname);
}
}
return true;
}
}
/**
* Check if type needs qualified references.
*
* @param fqname fully qualified class name
* @return true if needs qualification
*/
public boolean isQualified(String fqname) {
return !m_importedTypes.contains(fqname) && !m_localTypeName.containsKey(fqname);
}
/**
* Get map from imported fully-qualified class names to short names. Once this method is called, overrides of
* existing imports are blocked (since the existing imports may have been used), though added non-conflicting
* imports can still be added.
*
* @return map
*/
public Map getNameMap() {
if (m_nameMap == null) {
// build name map reflecting all current imports
m_nameMap = new HashMap(m_localTypeName);
for (Iterator iter = m_importedTypes.iterator(); iter.hasNext();) {
String impname = (String)iter.next();
if (impname.startsWith("java.lang.") && impname.lastIndexOf('.') <= "java.lang.".length()) {
m_nameMap.put(impname, impname.substring("java.lang.".length()));
} else {
int split = impname.lastIndexOf('.') + 1;
m_nameMap.put(impname, impname.substring(split));
}
}
}
return m_nameMap;
}
/**
* Get the name to be used for a type. If the type has been imported this returns the short form of the name;
* otherwise it just returns the fully-qualified name. This method forces a call to {@link #getNameMap()}, which in
* turn blocks removing any imports later.
*
* @param type fully-qualified type name
* @return name
*/
public String getName(String type) {
Map map = getNameMap();
String name = (String)map.get(type);
if (name == null) {
name = type;
}
return name;
}
/**
* Freeze imports and return a list of imports.
*
* @param cname simple name of class (used to identify inner class references)
* @return list
*/
public List freeze(String cname) {
List list = new ArrayList();
for (Iterator iter = m_importedTypes.iterator(); iter.hasNext();) {
String impname = (String)iter.next();
int length = m_packageName.length();
if (length > 0 && impname.length() > length && impname.startsWith(m_packageName)) {
int split = impname.indexOf('.', length+1);
if (split > 0 && !impname.substring(length+1, split).equals(cname)) {
list.add(impname);
}
} else if (!impname.startsWith("java.lang.") || impname.lastIndexOf('.') > "java.lang.".length()) {
list.add(impname);
}
}
return list;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/IClassHolder.java 0000644 0001750 0001750 00000011067 11175603262 025702 0 ustar twerner twerner /*
* Copyright (c) 2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.TypeDeclaration;
/**
* Interface for working with classes during code generation.
*
* @author Dennis M. Sosnoski
*/
public interface IClassHolder
{
/**
* Get simple name.
*
* @return name
*/
String getName();
/**
* Get fully-qualified name.
*
* @return name
*/
String getFullName();
/**
* Get containing class of inner class.
*
* @return outer containing class, or null if not an inner class
*/
IClassHolder getOuterClass();
/**
* Check if superclass is forced by schema model.
*
* @return true if superclass forced, false if not
*/
boolean isSuperClassForced();
/**
* Get name of base class to be extended.
*
* @return base (null if none)
*/
String getSuperClassName();
/**
* Set name of base class to be extended. This method can only be used if {@link #isSuperClassForced()} returns
* false.
*
* @param base fully-qualified class name of base class (null if none)
*/
void setSuperClassName(String base);
/**
* Set name of list implementation class to be used for initializing instances.
*
* @param list fully-qualified class name of list implementation (non-null)
*/
void setListImplementation(String list);
/**
* Add import for class. If the requested import doesn't conflict with the current set it's added, otherwise it's
* ignored.
*
* @param type fully qualified class name
* @return true if added as import
*/
boolean addImport(String type);
/**
* Get the name to be used for a type. If the type has been imported this returns the short form of the name;
* otherwise it just returns the fully-qualified name.
*
* @param type fully-qualified type name
* @return name
*/
String getTypeName(String type);
/**
* Get the interfaces implemented by this class.
*
* @return interface names
*/
String[] getInterfaces();
/**
* Get the fields defined in this class.
*
* @return fields
*/
FieldDeclaration[] getFields();
/**
* Get the methods defined in this class.
*
* @return methods
*/
MethodDeclaration[] getMethods();
/**
* Add an interface to this class definition.
*
* @param interf interface type
*/
void addInterface(String interf);
/**
* Add field declaration to class.
*
* @param field
*/
void addField(FieldDeclaration field);
/**
* Add method declaration to class.
*
* @param method
*/
void addMethod(MethodDeclaration method);
/**
* Add inner type declaration to class.
*
* @param type
*/
void addType(TypeDeclaration type);
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/EnumerationClassHolder.java 0000644 0001750 0001750 00000042343 11525073564 030006 0 ustar twerner twerner /*
* Copyright (c) 2006-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.util.ArrayList;
import java.util.Arrays;
import org.apache.log4j.Logger;
import org.eclipse.jdt.core.dom.InfixExpression.Operator;
import org.jibx.binding.model.BindingHolder;
import org.jibx.binding.model.FormatElement;
import org.jibx.schema.codegen.custom.SchemaRootBase;
import org.jibx.schema.codegen.extend.ClassDecorator;
import org.jibx.schema.codegen.extend.NameConverter;
import org.jibx.schema.elements.AnnotatedBase;
import org.jibx.schema.elements.FacetElement;
import org.jibx.schema.elements.FilteredSegmentList;
import org.jibx.schema.elements.SchemaBase;
import org.jibx.schema.elements.SimpleRestrictionElement;
import org.jibx.schema.elements.SimpleTypeElement;
import org.jibx.schema.elements.FacetElement.Enumeration;
/**
* Information for an enumeration class to be included in code generated from schema.
*
* @author Dennis M. Sosnoski
*/
public class EnumerationClassHolder extends ClassHolder
{
/** Instance field to hold text value. */
public static final String INSTANCEVALUE_FIELD = "value";
/** Static conversion method name, with exception if value not matched. */
public static final String CONVERTFORCE_METHOD = "fromValue";
/** Static conversion method name, with null return if value not matched. */
public static final String CONVERTIF_METHOD = "convert";
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(EnumerationClassHolder.class.getName());
/** Enumeration group defining the class. */
private ParentNode m_classGroup;
/** Binding definition element for this class. */
private FormatElement m_bindingFormat;
/**
* Constructor.
*
* @param name class name
* @param base base class name
* @param pack package information
* @param holder binding holder
* @param nconv name converter
* @param decorators class decorators
* @param inner use inner classes for substructures
*/
public EnumerationClassHolder(String name, String base, PackageHolder pack, BindingHolder holder,
NameConverter nconv, ClassDecorator[] decorators, boolean inner) {
super(name, base, pack, holder, nconv, decorators, inner, true);
}
/**
* Constructor for creating a child inner class definition.
*
* @param name class name
* @param context parent class
*/
protected EnumerationClassHolder(String name, ClassHolder context) {
super(name, context, true);
}
/**
* Set the binding component linked to this class.
*
* @param format binding definition element
*/
public void setBinding(FormatElement format) {
m_bindingFormat = format;
}
/**
* Convert an item structure to a class representation. This may include creating child classes, where necessary.
*
* @param group item group
* @param bindhold associated binding definition holder
*/
public void buildDataStructure(GroupItem group, BindingHolder bindhold) {
super.buildDataStructure(group, bindhold);
if (group.isEnumeration()) {
// set the basic configuration information
m_classGroup = new ParentNode(group, null);
m_classGroup.setDocumentation(extractDocumentation(group.getSchemaComponent()));
// just add String as an import to make sure it doesn't get overridden
m_importsTracker.addImport("java.lang.String", false);
} else {
throw new IllegalArgumentException("Internal error - group is not an enumeration");
}
}
/**
* Generate this class.
*
* @param verbose
* @param builder class source file builder
*/
public void generate(boolean verbose, SourceBuilder builder) {
// setup the class builder
Item item = m_classGroup.getItem();
ClassBuilder clasbuilder;
String name = getName();
boolean java5 = getSchemaCustom().getEnumType() == SchemaRootBase.ENUM_JAVA5;
if (m_outerClass == null) {
clasbuilder = builder.newMainClass(name, java5);
} else {
clasbuilder = builder.newInnerClass(name, m_outerClass.getBuilder(), java5);
}
// handle the common initialization
initClass(verbose, clasbuilder, m_classGroup);
// get the list of facets including enumerations
String fullname = getFullName();
if (s_logger.isInfoEnabled()) {
s_logger.info("Generating enumeration class " + fullname);
}
GroupItem group = (GroupItem)item;
AnnotatedBase comp = group.getFirstChild().getSchemaComponent();
if (comp.type() == SchemaBase.SIMPLETYPE_TYPE) {
comp = (AnnotatedBase)((SimpleTypeElement)comp).getDerivation();
}
SimpleRestrictionElement restrict = (SimpleRestrictionElement)comp;
FilteredSegmentList facets = restrict.getFacetsList();
if (java5) {
buildJava5Enumeration(name, fullname, facets, clasbuilder);
} else {
buildSimpleEnumeration(name, fullname, facets, clasbuilder);
}
// finish with inner class generation (which might be needed, if enumeration uses inlined type)
generateInner(verbose, builder);
finishClass(m_bindingFormat);
}
/**
* Build simple type-safe enumeration class.
*
* @param name simple class name
* @param fullname fully-qualified class name
* @param facets list of facets (may not all be xs:enumeration facets)
* @param clasbuilder
*/
private void buildSimpleEnumeration(String name, String fullname, FilteredSegmentList facets,
ClassBuilder clasbuilder) {
// create a field to hold the string value
String fieldname = m_nameConverter.toFieldName("value");
clasbuilder.addField(fieldname, "java.lang.String").setPrivateFinal();
// add private constructor with field assignment
MethodBuilder constr = clasbuilder.addConstructor(name);
constr.createBlock().addAssignVariableToField(INSTANCEVALUE_FIELD, fieldname);
constr.setPrivate();
constr.addParameter("value", "java.lang.String");
// create a static instance of class for each enumeration value
ArrayList enumpairs = new ArrayList();
for (int i = 0; i < facets.size(); i++) {
FacetElement facet = (FacetElement)facets.get(i);
if (facet.type() == SchemaBase.ENUMERATION_TYPE) {
// get value for this enumeration element
FacetElement.Enumeration enumelem = (Enumeration)facet;
String value = enumelem.getValue();
// create a field to hold the corresponding instance of class
String constname = m_nameSet.add(m_nameConverter.toConstantName(value));
FieldBuilder field = clasbuilder.addField(constname, name);
field.setPublicStaticFinal();
field.setInitializer(clasbuilder.newInstanceFromString(name, value));
field.addSourceComment(extractDocumentation(enumelem));
// track both the value and the corresponding field name
enumpairs.add(new StringPair(value, constname));
}
}
// sort the pairs by value text
StringPair[] pairs = (StringPair[])enumpairs.toArray(new StringPair[enumpairs.size()]);
Arrays.sort(pairs);
// create array of sorted text values
String valuesname = m_nameConverter.toStaticFieldName("values");
NewArrayBuilder array = clasbuilder.newArrayBuilder("java.lang.String");
for (int i = 0; i < pairs.length; i++) {
array.addStringLiteralOperand(pairs[i].getKey());
}
FieldBuilder field = clasbuilder.addField(valuesname, "java.lang.String[]");
field.setInitializer(array);
field.setPrivateStaticFinal();
// create matching array of instances corresponding to sorted values
String instsname = m_nameConverter.toStaticFieldName("instances");
array = clasbuilder.newArrayBuilder(fullname);
for (int i = 0; i < pairs.length; i++) {
array.addVariableOperand(pairs[i].getValue());
}
field = clasbuilder.addField(instsname, fullname + "[]");
field.setInitializer(array);
field.setPrivateStaticFinal();
// add toString method returning string value
MethodBuilder tostring = clasbuilder.addMethod("toString", "java.lang.String");
tostring.setPublic();
tostring.createBlock().addReturnNamed(fieldname);
// add static convert method returning instance for text value, or null if no match
MethodBuilder convert = clasbuilder.addMethod(CONVERTIF_METHOD, fullname);
convert.setPublicStatic();
convert.addParameter("value", "java.lang.String");
BlockBuilder body = convert.createBlock();
// build code to handle search for text value
InvocationBuilder invoke = clasbuilder.createStaticMethodCall("java.util.Arrays", "binarySearch");
invoke.addVariableOperand(valuesname);
invoke.addVariableOperand("value");
body.addLocalVariableDeclaration("int", "index", invoke);
// create the return block when value is matched
BlockBuilder retblock = clasbuilder.newBlock();
retblock.addReturnExpression(clasbuilder.buildArrayIndexAccess(instsname, "index"));
// create the null return block when value is not matched
BlockBuilder nullblock = clasbuilder.newBlock();
nullblock.addReturnNull();
// finish with the if statement that decides which to execute
InfixExpressionBuilder test = clasbuilder.buildNameOp("index", Operator.GREATER_EQUALS);
test.addNumberLiteralOperand("0");
body.addIfElseStatement(test, retblock, nullblock);
// add static valueOf method returning instance for text value
MethodBuilder valueof = clasbuilder.addMethod(CONVERTFORCE_METHOD, fullname);
valueof.setPublicStatic();
valueof.addParameter("text", "java.lang.String");
body = valueof.createBlock();
m_bindingFormat.setDeserializerName(getBindingName() + ".fromValue");
// build code to call convert method
invoke = clasbuilder.createLocalStaticMethodCall(CONVERTIF_METHOD);
invoke.addVariableOperand("text");
body.addLocalVariableDeclaration(fullname, "value", invoke);
// create the return block when value is found
retblock = clasbuilder.newBlock();
retblock.addReturnNamed("value");
// create the exception thrown when value is not found
BlockBuilder throwblock = clasbuilder.newBlock();
InfixExpressionBuilder strcat = clasbuilder.buildStringConcatenation("Value '");
strcat.addVariableOperand("text");
strcat.addStringLiteralOperand("' is not allowed");
throwblock.addThrowException("IllegalArgumentException", strcat);
// finish with the if statement that decides which to execute
test = clasbuilder.buildNameOp("value", Operator.EQUALS);
test.addNullOperand();
body.addIfElseStatement(test, throwblock, retblock);
s_logger.debug("Defined custom enumeration");
}
/**
* Build Java 5 enumeration class.
*
* @param name simple class name
* @param fullname fully-qualified class name
* @param facets list of facets (may not all be xs:enumeration facets)
* @param clasbuilder
*/
private void buildJava5Enumeration(String name, String fullname, FilteredSegmentList facets,
ClassBuilder clasbuilder) {
// check names to be used for enumeration values
boolean isdiff = false;
ArrayList enums = new ArrayList();
ArrayList names = new ArrayList();
for (int i = 0; i < facets.size(); i++) {
FacetElement facet = (FacetElement)facets.get(i);
if (facet.type() == SchemaBase.ENUMERATION_TYPE) {
// get value for this enumeration element
FacetElement.Enumeration enumelem = (Enumeration)facet;
enums.add(enumelem);
String value = enumelem.getValue();
// convert to an enum name
String constname = m_nameSet.add(m_nameConverter.toConstantName(value));
names.add(constname);
if (!constname.equals(value)) {
isdiff = true;
}
}
}
// add methods for conversion
if (isdiff) {
// create a field to hold the string value
String fieldname = m_nameConverter.toFieldName("value");
clasbuilder.addField(fieldname, "java.lang.String").setPrivateFinal();
// add private constructor with field assignment
MethodBuilder constr = clasbuilder.addConstructor(name);
constr.createBlock().addAssignVariableToField(INSTANCEVALUE_FIELD, fieldname);
constr.setPrivate();
constr.addParameter("value", "java.lang.String");
// add the actual enumeration values
for (int i = 0; i < names.size(); i++) {
FacetElement.Enumeration enumelem = (Enumeration)enums.get(i);
clasbuilder.addEnumConstant((String)names.get(i), extractDocumentation(enumelem),
enumelem.getValue());
}
// add xmlValue method returning string value
MethodBuilder tostring = clasbuilder.addMethod("xmlValue", "java.lang.String");
tostring.setPublic();
tostring.createBlock().addReturnNamed(fieldname);
m_bindingFormat.setEnumValueName("xmlValue");
// add static convert method returning instance for text value, or null if no match
MethodBuilder convert = clasbuilder.addMethod(CONVERTIF_METHOD, fullname);
convert.setPublicStatic();
convert.addParameter("value", "java.lang.String");
BlockBuilder body = convert.createBlock();
// create the return block when value is matched
BlockBuilder retblock = clasbuilder.newBlock();
retblock.addReturnNamed("inst");
// create the method calls to compare current instance text with value
InvocationBuilder valueexpr = clasbuilder.createNormalMethodCall("inst", "xmlValue");
InvocationBuilder equalsexpr = clasbuilder.createExpressionMethodCall(valueexpr, "equals");
equalsexpr.addVariableOperand("value");
// embed the complete if statement in body block of for loop
BlockBuilder forblock = clasbuilder.newBlock();
forblock.addIfStatement(equalsexpr, retblock);
InvocationBuilder loopexpr = clasbuilder.createLocalStaticMethodCall("values");
body.addSugaredForStatement("inst", fullname, loopexpr, forblock);
// finish with null return for match not found
body.addReturnNull();
s_logger.debug("Defined enum with separate values");
} else {
// add the actual definitions for a simple enum
for (int i = 0; i < names.size(); i++) {
FacetElement.Enumeration enumelem = (Enumeration)enums.get(i);
clasbuilder.addEnumConstant((String)names.get(i), extractDocumentation(enumelem));
}
s_logger.debug("Defined simple enum");
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/GroupItem.java 0000644 0001750 0001750 00000053773 11300632232 025300 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.apache.log4j.Logger;
import org.jibx.runtime.QName;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.codegen.custom.ComponentExtension;
import org.jibx.schema.elements.AnnotatedBase;
import org.jibx.schema.elements.ComplexExtensionElement;
import org.jibx.schema.elements.SchemaBase;
/**
* Information for a grouping of components (attributes, elements, compositors, and/or wildcards). This is used for
* both local groupings and global definitions.
*
* @author Dennis M. Sosnoski
*/
public class GroupItem extends Item
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(GroupItem.class.getName());
/** Flag for enumeration value. */
private boolean m_enumeration;
/** Inline references to this structure. */
private boolean m_inline;
/** Name to be used for generated class (null if inherited). */
private String m_className;
/** Number of child items in group. */
private int m_size;
/** First child (null if none). */
private Item m_head;
/** Last child (null if none). */
private Item m_tail;
/** Generated class information (null if inlined). */
private TypeData m_generateClass;
/** Flag for all child nodes are optional. In cases where multiple items are associated with the same schema
component, this is only meaningful for the topmost item. */
private boolean m_allOptional;
/** Attribute data present flag. */
private boolean m_attributePresent;
/** Element data present flag. */
private boolean m_elementPresent;
/** Character data content data present flag. */
private boolean m_contentPresent;
/**
* Internal constructor. This is used both for creating a new child group directly, and by the {@link
* DefinitionItem} subclass.
*
* @param comp schema component (should be the simpleType component in the case of an enumeration)
* @param parent (null if none)
*/
protected GroupItem(AnnotatedBase comp, GroupItem parent) {
super(comp, parent);
ComponentExtension exten = getComponentExtension();
m_className = exten.getClassName();
m_allOptional = true;
}
/**
* Copy constructor. This creates a deep copy with a new parent.
*
* @param original
* @param ref reference (for overrides to copy; null if none)
* @param parent (non-null)
*/
/*package*/ GroupItem(GroupItem original, Item ref, GroupItem parent) {
super(original, ref, original.getComponentExtension(), parent);
m_enumeration = original.m_enumeration;
for (Item child = original.getFirstChild(); child != null; child = child.getNext()) {
appendChild(child.copy(null, this));
}
m_inline = original.m_inline;
m_className = original.m_className;
if (parent == null || parent.getSchemaComponent() != getSchemaComponent()) {
GroupItem top = (GroupItem)original.getTopmost();
m_allOptional = top.m_allOptional;
m_attributePresent = top.m_attributePresent;
m_elementPresent = top.m_elementPresent;
m_contentPresent = top.m_contentPresent;
}
}
/**
* Constructor from a reference. This is only used for inlining a referenced definition. It merges usage information
* from the reference with a deep copy of the item structure of the definition.
*
* @param reference
* @param ext component extension to be linked with inlined definition
*/
/*package*/ GroupItem(ReferenceItem reference, ComponentExtension ext) {
super(reference, reference, ext, reference.getParent());
m_inline = true;
DefinitionItem definition = reference.getDefinition();
int type = reference.getSchemaComponent().type();
if (type == SchemaBase.ATTRIBUTEGROUP_TYPE || type == SchemaBase.GROUP_TYPE) {
m_allOptional = definition.isAllOptional();
}
m_attributePresent = definition.isAttributePresent();
m_elementPresent = definition.isElementPresent();
m_contentPresent = definition.isContentPresent();
appendChild(new GroupItem(definition, reference, this));
}
/**
* Check if this value represents an enumeration.
*
* @return enumeration
*/
public boolean isEnumeration() {
return m_enumeration;
}
/**
* Set value represents an enumeration flag.
*
* @param enumeration
*/
public void setEnumeration(boolean enumeration) {
m_enumeration = enumeration;
}
/**
* Append an item to the list of children.
*
* @param item
*/
private void appendChild(Item item) {
if (m_head == null) {
m_head = m_tail = item;
} else {
m_tail.m_next = item;
item.m_last = m_tail;
m_tail = item;
}
m_size++;
}
/**
* Add a child grouping structure.
*
* @param comp schema component
* @return structure
*/
public GroupItem addGroup(AnnotatedBase comp) {
GroupItem group = new GroupItem(comp, this);
appendChild(group);
return group;
}
/**
* Add a child reference structure.
*
* @param comp schema component
* @param ref referenced definition item
* @return reference
*/
public ReferenceItem addReference(AnnotatedBase comp, DefinitionItem ref) {
ReferenceItem reference = new ReferenceItem(comp, this, ref);
appendChild(reference);
return reference;
}
/**
* Add a child value.
*
* @param comp schema component extension
* @param type schema type name
* @param ref schema type equivalent (null if not appropriate)
* @return value
*/
public ValueItem addValue(AnnotatedBase comp, QName type, JavaType ref) {
ValueItem item = new ValueItem(comp, type, ref, this);
appendChild(item);
return item;
}
/**
* Add a child any.
*
* @param comp schema component
* @return value
*/
public AnyItem addAny(AnnotatedBase comp) {
AnyItem item = new AnyItem(comp, this);
appendChild(item);
return item;
}
/**
* Replace an item in this group with another item.
*
* @param current
* @param replace
*/
/*package*/ void replaceChild(Item current, Item replace) {
Item last = current.m_last;
Item next = current.m_next;
if (last == null) {
m_head = replace;
} else {
last.m_next = replace;
}
replace.m_last = last;
if (next == null) {
m_tail = replace;
} else {
next.m_last = replace;
}
replace.m_next = next;
}
/**
* Adopt the child items from another group as the child items of this group.
*
* @param group
*/
void adoptChildren(GroupItem group) {
m_size = group.m_size;
m_head = group.m_head;
m_tail = group.m_tail;
for (Item item = m_head; item != null; item = item.m_next) {
item.reparent(this);
}
}
/**
* Check if structure to be inlined.
*
* @return inline
*/
public boolean isInline() {
return m_inline;
}
/**
* Set structure to be inlined flag.
*
* @param inline
*/
public void setInline(boolean inline) {
m_inline = inline;
}
/**
* Get effective item name, applying inheritance if necessary.
*
* @return name
*/
public String getEffectiveClassName() {
GroupItem item = this;
while (item.getClassName() == null) {
item = item.getParent();
if (item == null) {
throw new IllegalStateException("Inherited class name with nothing to inherit");
}
}
return item.getClassName();
}
/**
* Get class name set directly for this group.
*
* @return name (null if to be inherited)
*/
public String getClassName() {
return m_className;
}
/**
* Check if the class name is fixed by configuration.
*
* @return true if fixed, false if not
*/
public boolean isFixedClassName() {
return getComponentExtension().getClassName() != null;
}
/**
* Set class name directly for this group. It is an error to call this method if the class name is fixed.
*
* @param name (null if to be inherited)
*/
public void setClassName(String name) {
if (isFixedClassName()) {
throw new IllegalStateException("Internal error - attempt to change configured class name");
} else {
m_className = name;
}
}
/**
* Get the number of items present in the group.
*
* @return count
*/
public int getChildCount() {
return m_size;
}
/**
* Get head item in list grouped by this structure.
*
* @return item (null if none)
*/
public Item getFirstChild() {
return m_head;
}
/**
* Get information for class to be generated.
*
* @return class
*/
public TypeData getGenerateClass() {
return m_generateClass;
}
/**
* Set information for class to be generated. If this group is a complexType extension and the base type is not
* being inlined, this sets the generated class to extend the base type class.
*
* @param clas
*/
public void setGenerateClass(TypeData clas) {
m_generateClass = clas;
}
/**
* Check if this group represents an extension reference.
*
* @return true if extension reference, false if not
*/
public boolean isExtensionReference() {
return m_head instanceof ReferenceItem && m_head.getSchemaComponent().type() == SchemaBase.EXTENSION_TYPE;
}
/**
* Handle groups which consist of a single type reference, or of an extension type reference, by subclassing the
* class generated for the reference.
* TODO: instead use separate extension test, since this won't be called for embedded types
*/
public void convertTypeReference() {
if (m_head instanceof ReferenceItem && (m_head == m_tail ||
m_head.getSchemaComponent() instanceof ComplexExtensionElement)) {
DefinitionItem def = ((ReferenceItem)m_head).getDefinition();
if (isEnumeration() == def.isEnumeration()) {
TypeData base = def.getGenerateClass();
if (s_logger.isDebugEnabled()) {
s_logger.debug("Setting base class for " + m_generateClass.getFullName() + " to " +
base.getFullName());
}
((ClassHolder)m_generateClass).setSuperClass(base);
m_head.setImplicit(true);
}
}
}
/**
* Copy the item under a different parent.
*
* @param ref reference (for overrides to copy; null if none)
* @param parent
* @return copy
*/
protected Item copy(Item ref, GroupItem parent) {
return new GroupItem(this, ref, parent);
}
/**
* Set attribute present in group. This cascades the attribute present flag upward through containing groups until
* one is found which defines an element name.
*/
protected void forceAttributePresent() {
if (!m_attributePresent && getSchemaComponent().type() != SchemaBase.ELEMENT_TYPE) {
GroupItem parent = getParent();
if (parent != null) {
parent.forceAttributePresent();
}
}
m_attributePresent = true;
}
/**
* Set element present in group. This cascades the element present flag upward through containing groups until
* one is found which defines an element name.
*/
protected void forceElementPresent() {
if (!m_elementPresent && getSchemaComponent().type() != SchemaBase.ELEMENT_TYPE) {
GroupItem parent = getParent();
if (parent != null) {
parent.forceElementPresent();
}
}
m_elementPresent = true;
}
/**
* Set character data content present in group. This cascades the content present flag upward through all containing
* groups until one is found which defines an element name.
*/
protected void forceContentPresent() {
if (!m_contentPresent && getSchemaComponent().type() != SchemaBase.ELEMENT_TYPE) {
GroupItem parent = getParent();
if (parent != null) {
parent.forceContentPresent();
}
}
m_contentPresent = true;
}
/**
* Set required item present in group. This cascades the required item present flag upward through all containing
* groups until one is found which defines either a wrapping element or a compositor other than a required sequence
* (because a required item present within a required sequence means that there will always be something present in
* the document, while any other type of compositor does not have this meaning).
*/
protected void forceRequiredPresent() {
if (m_allOptional) {
int type = getSchemaComponent().type();
boolean skip = false;
switch (type) {
case SchemaBase.ELEMENT_TYPE:
case SchemaBase.CHOICE_TYPE:
case SchemaBase.ALL_TYPE:
skip = true;
break;
case SchemaBase.SEQUENCE_TYPE:
skip = isOptional();
break;
}
if (!skip) {
GroupItem parent = getParent();
if (parent != null) {
parent.forceContentPresent();
}
}
}
m_allOptional = false;
}
/**
* Classify the content of this item as attribute, element, and/or character data content. For a group item, this
* just needs to call the corresponding method for each child item.
*/
protected void classifyContent() {
// handle basic classification for this component
super.classifyContent();
// classify each child component
for (Item item = m_head; item != null; item = item.getNext()) {
item.classifyContent();
}
// force off the 'all optional' state regardless of content if a required element or attribute
if (m_allOptional && !isOptional()) {
switch (getSchemaComponent().type()) {
case SchemaBase.ANY_TYPE:
case SchemaBase.ELEMENT_TYPE:
case SchemaBase.ANYATTRIBUTE_TYPE:
case SchemaBase.ATTRIBUTE_TYPE:
m_allOptional = false;
break;
}
}
}
/**
* Convert an embedded group to a freestanding definition. This creates a definition using a cloned copy of the
* structure of this group, then replaces this group with a reference to the definition.
* TODO: just adopt the child items, rather than cloning? minor performance gain.
*
* @return definition
*/
public DefinitionItem convertToDefinition() {
if (s_logger.isDebugEnabled()) {
s_logger.debug("Converting " + SchemaUtils.describeComponent(getSchemaComponent()) +
" to freestanding definition");
}
GroupItem parent = this;
while (! (parent instanceof DefinitionItem)) {
parent = parent.getParent();
}
DefinitionItem def = new DefinitionItem(this);
if (def.getClassName() == null) {
def.setClassName(getEffectiveClassName());
}
if (def.getName() == null) {
def.setName(getEffectiveName());
}
ReferenceItem ref = new ReferenceItem(this, def);
getParent().replaceChild(this, ref);
return def;
}
/**
* Build description of nested items.
*
* @param depth current nesting depth
* @param classified include classification details flag
* @return description
*/
public String nestedString(int depth, boolean classified) {
depth++;
Item child = getFirstChild();
StringBuffer buff = new StringBuffer(400);
while (child != null) {
buff.append(child.describe(depth, classified));
child = child.getNext();
}
return buff.toString();
}
/**
* Check if all immediate child nodes are optional. This is needed when handling code generation for a
* reference to a group or attributeGroup handled as a separate object, since that object only needs to be
* present if one or more of the values are present. This method is only meaningful for the topmost item associated
* with a particular schema component (those for which {@link Item#isTopmost()} returns true).
*
* @return true if all child nodes optional, false if not
*/
public boolean isAllOptional() {
return m_allOptional;
}
/**
* Check if an attribute is part of this item. This is only true for items corresponding to attribute
* definitions, and groupings including these items which do not define an element name. This method is only
* meaningful for the topmost item associated with a particular schema component (those for which {@link
* Item#isTopmost()} returns true).
*
* @return true if attribute
*/
public boolean isAttributePresent() {
return m_attributePresent;
}
/**
* Check if a child elements is part of this item. This is true for all items corresponding to element
* definitions, and all groupings which include such an item. This method is only meaningful for the topmost item
* associated with a particular schema component (those for which {@link Item#isTopmost()} returns
* true).
*
* @return true if content
*/
public boolean isElementPresent() {
return m_elementPresent;
}
/**
* Check if character data content is part of this item. This is true for all items corresponding to
* simpleContent definitions, and all groupings which include such an item. This method is only meaningful for the
* topmost item associated with a particular schema component (those for which {@link Item#isTopmost()} returns
* true).
*
* @return true if content
*/
public boolean isContentPresent() {
return m_contentPresent;
}
/**
* Generate a description of the item, including all nested items.
*
* @param depth current nesting depth
* @param classified include classification details flag
* @return description
*/
protected String describe(int depth, boolean classified) {
StringBuffer buff = new StringBuffer(depth + 50);
buff.append(leadString(depth));
if (isInline()) {
buff.append("inlined ");
}
if (m_enumeration) {
buff.append("enumeration ");
}
AnnotatedBase comp = getSchemaComponent();
if (isTopmost()) {
if (classified) {
if (m_attributePresent) {
if (m_contentPresent) {
buff.append("attribute+content ");
} else {
buff.append("attribute ");
}
} else if (m_contentPresent) {
buff.append("content ");
}
}
} else {
buff.append("duplicate ");
}
buff.append("group with class name ");
buff.append(getClassName());
buff.append(" and value name ");
buff.append(getName());
if (classified && isTopmost()) {
buff.append(m_allOptional ? " (all items optional)" : " (not all items optional)");
}
buff.append(": ");
buff.append(SchemaUtils.describeComponent(comp));
buff.append('\n');
buff.append(nestedString(depth, classified));
return buff.toString();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/StatementBuilderBase.java 0000644 0001750 0001750 00000004262 10752422370 027432 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.Statement;
/**
* Base class for all statement builders. This wraps the AST representation with convenience methods and added control
* information.
*
* @author Dennis M. Sosnoski
*/
public abstract class StatementBuilderBase extends ASTBuilderBase
{
/** Source builder. */
protected final ClassBuilder m_source;
/**
* Constructor.
*
* @param source
*/
public StatementBuilderBase(ClassBuilder source) {
super(source.getAST());
m_source = source;
}
/**
* Get the statement.
*
* @return statement
*/
abstract Statement getStatement();
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/SchemaDocumentationGenerator.java 0000644 0001750 0001750 00000060650 11520376634 031175 0 ustar twerner twerner /*
* Copyright (c) 2008-2011, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.io.IOException;
import java.io.StringWriter;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Logger;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IMarshaller;
import org.jibx.runtime.IXMLWriter;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.runtime.impl.MarshallingContext;
import org.jibx.schema.INamed;
import org.jibx.schema.IReference;
import org.jibx.schema.SchemaContextTracker;
import org.jibx.schema.SchemaVisitor;
import org.jibx.schema.TreeWalker;
import org.jibx.schema.codegen.custom.ComponentExtension;
import org.jibx.schema.elements.AnnotatedBase;
import org.jibx.schema.elements.AnnotationElement;
import org.jibx.schema.elements.AttributeElement;
import org.jibx.schema.elements.ElementElement;
import org.jibx.schema.elements.KeyBase;
import org.jibx.schema.elements.OpenAttrBase;
import org.jibx.schema.elements.SchemaBase;
import org.jibx.util.InsertionOrderedSet;
import org.jibx.util.UniqueNameSet;
/**
* Visitor to write a filtered view of a schema definition matching the data structure of a class. This is used when
* schema fragments are included in class documentation.
*/
public class SchemaDocumentationGenerator
{
/** Leading text for comment lines. */
public static final String COMMENT_LEAD_TEXT = "\n * ";
/** Schema definitions namespace URI. */
private static final String SCHEMA_DEFINITIONS_NS = "http://www.w3.org/2001/XMLSchema";
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(SchemaDocumentationGenerator.class.getName());
/** Extract binding factory. */
private final IBindingFactory m_factory;
/** Schema definitions namespace index. */
private final int m_schemaIndex;
/** Schema definitions namespace prefix. */
private final String m_schemaPrefix;
/** Set of namespace URIs defined in binding. */
private final Set m_namespaceSet;
/** Marshaller instance for writing schema fragments. */
private final MarshallingContext m_context;
/**
* Constructor.
*
* @throws JiBXException on error loading binding information
*/
public SchemaDocumentationGenerator() throws JiBXException {
m_factory = BindingDirectory.getFactory("schema_extract_binding", "org.jibx.schema.codegen");
int index = 0;
String[] uris = m_factory.getNamespaces();
m_namespaceSet = new HashSet();
for (int i = 1; i < uris.length; i++) {
m_namespaceSet.add(uris[i]);
if (SCHEMA_DEFINITIONS_NS.equals(uris[i])) {
index = i;
}
}
if (index < 0) {
throw new JiBXException("Schema namespace definition not found");
}
m_schemaIndex = index;
m_schemaPrefix = m_factory.getPrefixes()[index];
m_context = (MarshallingContext)m_factory.createMarshallingContext();
m_context.setIndent(2, COMMENT_LEAD_TEXT, ' ');
}
/**
* Scan schema component references from item tree. This recursively constructs (1) a map from schema components
* represented by separate classes to the corresponding class information, (2) a set of schema global definitions
* included in the item tree, and (3) a set of namespace URIs for referenced components.
*
* @param group item grouping to be processed
* @param comptoclas map from schema component to corresponding {@link ClassHolder}
* @param refcomps set of schema global definitions incorporated into this tree
* @param uritoprefix map from namespaces used by referenced definitions to the corresponding prefixes
*/
private void scanItemTree(GroupItem group, Map comptoclas, Set refcomps, Map uritoprefix) {
OpenAttrBase topcomp = group.getSchemaComponent();
for (Item item = group.getFirstChild(); item != null; item = item.getNext()) {
if (!item.isIgnored()) {
// start by checking if we've crossed into a different schema definition
OpenAttrBase comp = item.getSchemaComponent();
while (comp != topcomp) {
if (comp.isGlobal()) {
if (!(item instanceof ReferenceItem)) {
refcomps.add(comp);
}
QName qname = ((INamed)comp).getQName();
if (qname == null) {
throw new IllegalStateException("Internal error - no name on global definition");
} else {
uritoprefix.put(qname.getUri(), qname.getPrefix());
}
break;
} else {
comp = comp.getParent();
}
}
// now check the actual item type
if (item instanceof GroupItem) {
// check non-inlined group which uses separate class
GroupItem childgroup = (GroupItem)item;
if (!childgroup.isIgnored()) {
if (childgroup.isInline()) {
scanItemTree(childgroup, comptoclas, refcomps, uritoprefix);
} else {
// add component to class mapping to stop schema fragment generation when reached
TypeData genclas = childgroup.getGenerateClass();
if (genclas == null) {
throw new IllegalStateException("Internal error - no generate class");
} else {
comptoclas.put(childgroup.getSchemaComponent(), genclas);
}
// check for type definition or reference used (with associated namespace reference)
QName tname = null;
comp = item.getSchemaComponent();
switch (comp.type()) {
case SchemaBase.ATTRIBUTE_TYPE:
tname = ((AttributeElement)comp).getType();
break;
case SchemaBase.ELEMENT_TYPE:
tname = ((ElementElement)comp).getType();
break;
}
if (tname != null) {
uritoprefix.put(tname.getUri(), tname.getPrefix());
}
QName rname = null;
if (comp instanceof IReference) {
rname = ((IReference)comp).getRef();
}
if (rname != null) {
uritoprefix.put(rname.getUri(), rname.getPrefix());
}
}
}
} else if (item instanceof ReferenceItem) {
// make sure namespace collected for reference
DefinitionItem def = ((ReferenceItem)item).getDefinition();
AnnotatedBase defcomp = def.getSchemaComponent();
if (defcomp instanceof INamed) {
QName qname = ((INamed)defcomp).getQName();
if (qname == null && defcomp instanceof IReference) {
qname = ((IReference)defcomp).getRef();
}
if (qname != null) {
uritoprefix.put(qname.getUri(), qname.getPrefix());
}
}
TypeData genclas = def.getGenerateClass();
if (genclas != null) {
comptoclas.put(defcomp, genclas);
}
}
}
}
// also check for substitution group used with element
if (topcomp.type() == SchemaBase.ELEMENT_TYPE) {
QName sname = ((ElementElement)topcomp).getSubstitutionGroup();
if (sname != null) {
uritoprefix.put(sname.getUri(), sname.getPrefix());
}
}
}
/**
* Escape a special character in a text string.
*
* @param chr
* @param escape
* @param text
* @param buff
*/
private void escapeText(char chr, String escape, String text, StringBuffer buff) {
int base = 0;
int scan;
while ((scan = text.indexOf(chr, base)) >= 0) {
buff.append(text.substring(base, scan));
buff.append(escape);
base = scan + 1;
}
buff.append(text.substring(base));
}
/**
* Generate documentation from the schema component corresponding to a class.
*
* @param group item group for class
* @param dropanno delete annotations from schema documentation flag
* @return schema extract documentation
*/
public String generate(GroupItem group, boolean dropanno) {
if (group.isIgnored()) {
return null;
} else {
// scan the item tree structure to find schema components needing special handling
Map comptoclas = new HashMap();
InsertionOrderedSet refcomps = new InsertionOrderedSet();
AnnotatedBase grpcomp = group.getSchemaComponent();
refcomps.add(grpcomp);
Map uritoprefix = new HashMap();
if (grpcomp instanceof INamed) {
QName qname = ((INamed)grpcomp).getQName();
if (qname == null && grpcomp instanceof IReference) {
qname = ((IReference)grpcomp).getRef();
}
if (qname != null && qname.getUri() != null) {
uritoprefix.put(qname.getUri(), qname.getPrefix());
}
}
scanItemTree(group, comptoclas, refcomps, uritoprefix);
// get full set of namespaces and corresponding prefixes needed for extracts
UniqueNameSet prefset = new UniqueNameSet();
prefset.add(m_schemaPrefix);
for (Iterator iter = uritoprefix.keySet().iterator(); iter.hasNext();) {
String uri = (String)iter.next();
if (!SCHEMA_DEFINITIONS_NS.equals(uri)) {
String prefix = (String)uritoprefix.get(uri);
if (prefix == null) {
prefix = "ns";
}
prefix = prefset.add(prefix);
uritoprefix.put(uri, prefix);
}
}
// set the writer to be used for output
StringWriter strwriter = new StringWriter();
m_context.setOutput(strwriter);
// define namespaces as extension to those used in binding
int count = uritoprefix.size();
String[] uris = (String[])uritoprefix.keySet().toArray(new String[count]);
IXMLWriter xmlwriter = m_context.getXmlWriter();
int base = xmlwriter.getNamespaceCount();
xmlwriter.pushExtensionNamespaces(uris);
// build the arrays of namespace indexes and prefixes for use on marshalled root elements
int length = count;
if (!uritoprefix.containsKey(null)) {
length++;
}
String[] prefixes = new String[length];
int[] indexes = new int[length];
int fill = 0;
for (int i = 0; i < count; i++) {
String uri = uris[i];
if (uri != null) {
prefixes[fill] = (String)uritoprefix.get(uris[i]);
indexes[fill] = base+fill;
fill++;
}
}
prefixes[fill] = m_schemaPrefix;
indexes[fill] = m_schemaIndex;
// build schema extracts from main component and all referenced components
String clasname = group.getGenerateClass().getFullName();
TreeWalker walker = new TreeWalker(null, new SchemaContextTracker());
boolean ref = false;
List list = refcomps.asList();
for (Iterator iter = list.iterator(); iter.hasNext();) {
// add a blank line separating components
if (ref) {
strwriter.write(COMMENT_LEAD_TEXT);
} else {
ref = true;
}
// add any necessary namespace declarations
AnnotatedBase comp = (AnnotatedBase)iter.next();
for (Iterator jter = uritoprefix.keySet().iterator(); jter.hasNext();) {
String uri = (String)jter.next();
comp.addNamespaceDeclaration((String)uritoprefix.get(uri), uri);
}
// write the documentation
DocumentationVisitor visitor = new DocumentationVisitor(comptoclas, clasname, comp, dropanno, ref,
indexes, prefixes);
walker.walkElement(comp, visitor);
strwriter.flush();
}
// convert generated schema fragment to plain text for embedding
String text = strwriter.toString();
StringBuffer buff = new StringBuffer(text.length() + text.length() / 4);
if (text.indexOf('&') >= 0) {
escapeText('&', "&", text, buff);
text = buff.toString();
buff = new StringBuffer(text.length() + text.length() / 4);
}
buff.append("Schema fragment(s) for this class:");
buff.append(COMMENT_LEAD_TEXT);
buff.append("");
buff.append(COMMENT_LEAD_TEXT);
escapeText('<', "<", text, buff);
buff.append(COMMENT_LEAD_TEXT);
buff.append("");
// make sure there's no embedded comment end marker
int index = buff.length();
while ((index = buff.lastIndexOf("*/", index)) >= 0) {
buff.replace(index, index+2, "* /");
}
return buff.toString();
}
}
/**
* Visitor to write the filtered view of a schema definition matching the data structure of a class. This uses a
* supplied map for components which are represented by separate classes, which need to be replaced in the filtered
* view by a reference to the appropriate class.
*/
private class DocumentationVisitor extends SchemaVisitor
{
/** Map from schema components with separate classes to the class information. */
private final Map m_componentClassMap;
/** Fully-qualified name of class containing documentation. */
private final String m_className;
/** Root component to be documented. */
private final AnnotatedBase m_component;
/** Delete annotations from schema documentation flag. */
private final boolean m_dropAnnotations;
/** Reference component with separate class flag. */
private final boolean m_reference;
/** Namespace indexes for use on marshalling root element. */
private final int[] m_nsIndexes;
/** Namespace prefixes for use on marshalling root element. */
private final String[] m_nsPrefixes;
/**
* Constructor.
*
* @param comptoclas map from schema components to class information
* @param clasname fully-qualified class name to be stripped from class references
* @param comp top-level component for documentation
* @param dropanno delete annotations from schema documentation flag
* @param ref reference component with separate class flag
* @param indexes namespace indexes for use on marshalling root element
* @param prefixes namespace prefixes for use on marshalling root element
*/
public DocumentationVisitor(Map comptoclas, String clasname, AnnotatedBase comp, boolean dropanno, boolean ref,
int[] indexes, String[] prefixes) {
m_componentClassMap = comptoclas;
m_className = clasname;
m_component = comp;
m_dropAnnotations = dropanno;
m_reference = ref;
m_nsIndexes = indexes;
m_nsPrefixes = prefixes;
}
/**
* Exit a schema node. This just writes the end tag for the node.
*
* @param node
*/
public void exit(SchemaBase node) {
try {
m_context.endTag(m_schemaIndex, node.name());
} catch (JiBXException e) {
s_logger.fatal("Binding failed", e);
throw new IllegalStateException("Internal error - binding failed: " + e.getMessage());
}
}
/**
* Exit an annotation element. If annotations are being deleted, this just returns without calling the
* next-level method, so that no close tag will be written.
*
* @param node
*/
public void exit(AnnotationElement node) {
if (!m_dropAnnotations) {
super.exit(node);
}
}
/**
* Exit an element element. If the extension says the element is excluded, this just returns without calling the
* next-level method, so that no close tag will be written.
*
* @param node
*/
public void exit(ElementElement node) {
Object extension = node.getExtension();
if (!(extension instanceof ComponentExtension) || !((ComponentExtension)extension).isIgnored()) {
super.exit(node);
}
}
/**
* Exit an identity constraint element. This just always returns immediately, since the identity constraint
* elements are handled in-line in the binding.
*
* @param node
*/
public void exit(KeyBase node) {
}
/**
* Visit a schema node. This first writes the start tag for the node. If the schema node is represented by a
* separate class this then just writes text content referencing that class, and returns blocking further
* expansion; otherwise, it just returns for further expansion requested.
*
* @param node
* @return true if expanding content, false if content replaced by reference
*/
public boolean visit(SchemaBase node) {
boolean expand = false;
try {
// first marshal the element start tag and attributes
if (node == m_component) {
int[] copy = new int[m_nsIndexes.length];
System.arraycopy(m_nsIndexes, 0, copy, 0, m_nsIndexes.length);
m_context.startTagNamespaces(m_schemaIndex, node.name(), copy, m_nsPrefixes);
} else {
m_context.startTagAttributes(m_schemaIndex, node.name());
}
IMarshaller marshaller = m_context.getMarshaller(node.getClass().getName());
marshaller.marshal(node, m_context);
m_context.closeStartContent();
// check for separate class reference to determine content handling
IClassHolder clas = (IClassHolder)m_componentClassMap.get(node);
if (clas != null && (m_reference || node != m_component)) {
// replace content with comment reference to class holding data
String name = clas.getFullName();
StringBuffer text = new StringBuffer();
int length = m_className.length();
if (name.startsWith(m_className) && name.length() > length && name.charAt(length) == '.') {
text.append(" Reference to inner class ");
text.append(name.substring(length+1));
} else {
text.append(" Reference to class ");
text.append(name);
}
text.append(' ');
IXMLWriter writer = m_context.getXmlWriter();
writer.indent();
writer.writeComment(text.toString());
} else {
expand = true;
}
} catch (IOException e) {
s_logger.fatal("Write failed", e);
throw new IllegalStateException("Internal error - write failed: " + e.getMessage());
} catch (JiBXException e) {
s_logger.fatal("Error writing schema XML representation", e);
throw new IllegalStateException("Internal error - error writing schema XML representation: " + e.getMessage());
}
return expand;
}
/**
* Visit an annotation element. If annotations are being deleted this just returns without calling the
* next-level method, so that the element will be ignored.
*
* @param node
* @return false if annotations to be deleted, otherwise the result of the next-level method
*/
public boolean visit(AnnotationElement node) {
if (m_dropAnnotations) {
return false;
} else {
return super.visit(node);
}
}
/**
* Visit an element element. If the extension says this is excluded the element is dropped from the generated
* schema fragment.
*
* @param node
* @return false if element excluded, otherwise the result of the next-level method
*/
public boolean visit(ElementElement node) {
Object extension = node.getExtension();
if (extension instanceof ComponentExtension && ((ComponentExtension)extension).isIgnored()) {
return false;
} else {
return super.visit(node);
}
}
/**
* Visit an identity constraint element. This just always returns false, since the identity
* constraint elements are handled in-line in the binding.
*
* @param node
* @return false to block further expansion
*/
public boolean visit(KeyBase node) {
return false;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/NewInstanceBuilder.java 0000644 0001750 0001750 00000005523 11002543776 027115 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
import org.eclipse.jdt.core.dom.ClassInstanceCreation;
import org.eclipse.jdt.core.dom.Expression;
/**
* Abstract syntax tree new instance expression builder. This adds convenience methods and control information to the
* base builder.
*/
public class NewInstanceBuilder extends ExpressionBuilderBase
{
/** New instance expression. */
private final ClassInstanceCreation m_newInstance;
/**
* Constructor.
*
* @param source
* @param expr
*/
public NewInstanceBuilder(ClassBuilder source, ClassInstanceCreation expr) {
super(source, expr);
m_newInstance = expr;
}
/**
* Add operand to expression. This just adds the supplied operand expression as a new constructor parameter.
*
* @param operand
*/
protected void addOperand(Expression operand) {
m_newInstance.arguments().add(operand);
}
/**
* Create an anonymous inner class as the target of this new instance expression.
*
* @return class
*/
public ClassBuilder addAnonymousInnerClass() {
AnonymousClassDeclaration clas = m_ast.newAnonymousClassDeclaration();
m_newInstance.setAnonymousClassDeclaration(clas);
return new ClassBuilder(clas, m_source);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/classes/ 0000755 0001750 0001750 00000000000 11300355300 024136 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/StringObjectPair.java 0000644 0001750 0001750 00000004037 10752422370 026575 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
/**
* Holder for a pair consisting of a key string and a value object.
*/
public class StringObjectPair extends StringKeyed
{
/** Object value. */
private final Object m_value;
/**
* Constructor.
*
* @param key
* @param value
*/
public StringObjectPair(String key, Object value) {
super(key);
m_value = value;
}
/**
* Get the value object.
*
* @return value
*/
public Object getValue() {
return m_value;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/NewArrayBuilder.java 0000644 0001750 0001750 00000005510 11365655716 026435 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.ArrayCreation;
import org.eclipse.jdt.core.dom.ArrayInitializer;
import org.eclipse.jdt.core.dom.Expression;
/**
* Abstract syntax tree new array expression builder. This adds convenience methods and control information to the base
* builder.
*/
public class NewArrayBuilder extends ExpressionBuilderBase
{
/** Array creation expression. */
private final ArrayCreation m_arrayCreation;
/**
* Constructor.
*
* @param source
* @param expr
*/
public NewArrayBuilder(ClassBuilder source, ArrayCreation expr) {
super(source, expr);
m_arrayCreation = expr;
}
/**
* Add operand to expression. This just adds the supplied operand expression as a new initializer value.
*
* @param operand
*/
protected void addOperand(Expression operand) {
ArrayInitializer init = m_arrayCreation.getInitializer();
if (init == null) {
init = m_ast.newArrayInitializer();
m_arrayCreation.setInitializer(init);
}
init.expressions().add(operand);
}
/**
* Set the size of the array.
*
* @param size
*/
public void setSize(ExpressionBuilderBase size) {
m_arrayCreation.dimensions().add(size.getExpression());
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/CastBuilder.java 0000644 0001750 0001750 00000005203 10756325130 025561 0 ustar twerner twerner /*
* Copyright (c) 2008, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.CastExpression;
import org.eclipse.jdt.core.dom.Expression;
/**
* Abstract syntax tree array cast expression builder. This adds convenience methods and control information to the base
* builder.
*/
public class CastBuilder extends ExpressionBuilderBase
{
/** Cast expression. */
private final CastExpression m_cast;
/** Flag for expression set. */
private boolean m_set;
/**
* Constructor.
*
* @param source
* @param expr
*/
public CastBuilder(ClassBuilder source, CastExpression expr) {
super(source, expr);
m_cast = expr;
}
/**
* Add operand to expression. This just sets the supplied operand expression as the target, as long as the target
* has not been set previously.
*
* @param operand
*/
protected void addOperand(Expression operand) {
if (m_set) {
throw new IllegalStateException("Internal error: attempt to set cast expression more than once");
} else {
m_cast.setExpression(operand);
m_set = true;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/BlockBuilder.java 0000644 0001750 0001750 00000036434 11365654720 025742 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import org.eclipse.jdt.core.dom.Assignment;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.ClassInstanceCreation;
import org.eclipse.jdt.core.dom.EnhancedForStatement;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.FieldAccess;
import org.eclipse.jdt.core.dom.ForStatement;
import org.eclipse.jdt.core.dom.IfStatement;
import org.eclipse.jdt.core.dom.InfixExpression;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.PrefixExpression;
import org.eclipse.jdt.core.dom.PrimitiveType;
import org.eclipse.jdt.core.dom.ReturnStatement;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.Statement;
import org.eclipse.jdt.core.dom.ThrowStatement;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
import org.eclipse.jdt.core.dom.InfixExpression.Operator;
/**
* Block builder. This wraps the AST block representation with convenience methods and added control information.
*/
public class BlockBuilder extends StatementBuilderBase
{
/** Compilation unit. */
private final Block m_block;
/**
* Constructor.
*
* @param source
* @param block
*/
public BlockBuilder(ClassBuilder source, Block block) {
super(source);
m_block = block;
}
/**
* Get the statement.
*
* @return statement
*/
Statement getStatement() {
return m_block;
}
/**
* Append an assignment from an expression to a field or local variable.
*
* @param expr
* @param name
*/
public void addAssignToName(Expression expr, String name) {
Assignment asgn = m_ast.newAssignment();
asgn.setLeftHandSide(m_ast.newSimpleName(name));
asgn.setRightHandSide(expr);
m_block.statements().add(m_ast.newExpressionStatement(asgn));
}
/**
* Append an assignment from a local variable to a field. This handles the case where the local variable name is the
* same as the field name.
*
* @param vname
* @param fname
*/
public void addAssignVariableToField(String vname, String fname) {
Assignment asgn = m_ast.newAssignment();
if (fname.equals(vname)) {
FieldAccess access = m_ast.newFieldAccess();
access.setExpression(m_ast.newThisExpression());
access.setName(m_ast.newSimpleName(fname));
asgn.setLeftHandSide(access);
} else {
asgn.setLeftHandSide(m_ast.newSimpleName(fname));
}
asgn.setRightHandSide(m_ast.newSimpleName(vname));
m_block.statements().add(m_ast.newExpressionStatement(asgn));
}
/**
* Append a local variable declaration.
*
* @param type
* @param vname
*/
public void addLocalVariableDeclaration(String type, String vname) {
VariableDeclarationFragment vfrag = m_ast.newVariableDeclarationFragment();
vfrag.setName(m_ast.newSimpleName(vname));
VariableDeclarationStatement stmt = m_ast.newVariableDeclarationStatement(vfrag);
stmt.setType(m_source.createType(type));
m_block.statements().add(stmt);
}
/**
* Append a local variable declaration with initializer expression. This variation takes the actual type as a
* parameter.
*
* @param type
* @param vname
* @param expr initializer expression
*/
public void addLocalVariableDeclaration(Type type, String vname, ExpressionBuilderBase expr) {
VariableDeclarationFragment vfrag = m_ast.newVariableDeclarationFragment();
vfrag.setName(m_ast.newSimpleName(vname));
vfrag.setInitializer(expr.getExpression());
VariableDeclarationStatement stmt = m_ast.newVariableDeclarationStatement(vfrag);
stmt.setType(type);
m_block.statements().add(stmt);
}
/**
* Append a local variable declaration with initializer expression. This variation takes the type name as a
* parameter.
*
* @param tname
* @param vname
* @param expr initializer expression
*/
public void addLocalVariableDeclaration(String tname, String vname, ExpressionBuilderBase expr) {
addLocalVariableDeclaration(m_source.createType(tname), vname, expr);
}
/**
* Append a simple 'if' statement (no else).
*
* @param expr conditional expression
* @param ifblock block executed when condition true
*/
public void addIfStatement(ExpressionBuilderBase expr, BlockBuilder ifblock) {
IfStatement ifstmt = m_ast.newIfStatement();
ifstmt.setExpression(expr.getExpression());
ifstmt.setThenStatement(ifblock.m_block);
m_block.statements().add(ifstmt);
}
/**
* Append an 'if-else' statement.
*
* @param expr conditional expression
* @param ifblock block executed when condition true
* @param elseblock block executed when condition false
*/
public void addIfElseStatement(ExpressionBuilderBase expr, BlockBuilder ifblock, BlockBuilder elseblock) {
IfStatement ifstmt = m_ast.newIfStatement();
ifstmt.setExpression(expr.getExpression());
ifstmt.setThenStatement(ifblock.m_block);
ifstmt.setElseStatement(elseblock.m_block);
m_block.statements().add(ifstmt);
}
/**
* Append an 'if-else-if' statement.
*
* @param ifexpr if conditional expression
* @param elsexpr if conditional expression
* @param ifblock block executed when condition true
* @param elseblock block executed when condition false
*/
public void addIfElseIfStatement(ExpressionBuilderBase ifexpr, ExpressionBuilderBase elsexpr, BlockBuilder ifblock,
BlockBuilder elseblock) {
IfStatement ifstmt = m_ast.newIfStatement();
ifstmt.setExpression(ifexpr.getExpression());
ifstmt.setThenStatement(ifblock.m_block);
IfStatement elseifstmt = m_ast.newIfStatement();
elseifstmt.setExpression(elsexpr.getExpression());
elseifstmt.setThenStatement(elseblock.m_block);
ifstmt.setElseStatement(elseifstmt);
m_block.statements().add(ifstmt);
}
/**
* Append a three-part 'for' statement with an associated variable. This assumes the first part is a local variable
* declaration with an initializer expression, while the other two parts are just expressions.
*
* @param name iteration variable name
* @param type variable type
* @param init variable initialization expression
* @param test loop test expression (second part of 'for')
* @param post post-loop expression (optional third part of 'for', null if none)
* @param block statement body block
*/
private void addForStatement(String name, Type type, Expression init, Expression test, Expression post,
BlockBuilder block) {
ForStatement stmt = m_ast.newForStatement();
VariableDeclarationFragment declfrag = m_ast.newVariableDeclarationFragment();
declfrag.setName(m_ast.newSimpleName(name));
declfrag.setInitializer(init);
VariableDeclarationExpression varexpr = m_ast.newVariableDeclarationExpression(declfrag);
varexpr.setType(type);
stmt.initializers().add(varexpr);
stmt.setExpression(test);
if (post != null) {
stmt.updaters().add(post);
}
stmt.setBody(block.getStatement());
m_block.statements().add(stmt);
}
/**
* Append a standard 'for' statement using an iterator.
*
* @param name iteration variable name
* @param type variable type (must be an iterator subclass or generic type)
* @param init variable initialization expression
* @param block statement body block
*/
public void addIteratedForStatement(String name, Type type, ExpressionBuilderBase init, BlockBuilder block) {
MethodInvocation methcall = m_ast.newMethodInvocation();
methcall.setExpression(m_ast.newSimpleName(name));
methcall.setName(m_ast.newSimpleName("hasNext"));
addForStatement(name, type, init.getExpression(), methcall, null, block);
}
/**
* Append a standard 'for' statement using an index variable over an array. The index is always initialized to '0',
* and incremented each time the loop is executed until the size of the array is reached.
*
* @param name index variable name
* @param array array name
* @param block statement body block
*/
public void addIndexedForStatement(String name, String array, BlockBuilder block) {
InfixExpression test = m_ast.newInfixExpression();
test.setOperator(Operator.LESS);
test.setLeftOperand(m_ast.newSimpleName(name));
FieldAccess access = m_ast.newFieldAccess();
access.setExpression(m_ast.newSimpleName(array));
access.setName(m_ast.newSimpleName("length"));
test.setRightOperand(access);
PrefixExpression post = m_ast.newPrefixExpression();
post.setOperator(PrefixExpression.Operator.INCREMENT);
post.setOperand(m_ast.newSimpleName(name));
addForStatement(name, m_ast.newPrimitiveType(PrimitiveType.INT), m_ast.newNumberLiteral("0"), test,
post, block);
}
/**
* Append a Java 5 "enhanced" 'for' statement.
*
* @param name iteration variable name
* @param type iteration variable type
* @param expr iteration source expression
* @param block statement body block
*/
public void addSugaredForStatement(String name, String type, ExpressionBuilderBase expr, BlockBuilder block) {
EnhancedForStatement stmt = m_ast.newEnhancedForStatement();
stmt.setExpression(expr.getExpression());
SingleVariableDeclaration decl = m_ast.newSingleVariableDeclaration();
decl.setName(m_ast.newSimpleName(name));
decl.setType(m_source.createType(type));
stmt.setParameter(decl);
stmt.setBody(block.getStatement());
m_block.statements().add(stmt);
}
/**
* Append a statement returning the value of an expression.
*
* @param expr expression
*/
public void addReturnExpression(ExpressionBuilderBase expr) {
ReturnStatement ret = m_ast.newReturnStatement();
ret.setExpression(expr.getExpression());
m_block.statements().add(ret);
}
/**
* Append a statement returning the value of a field or local variable.
*
* @param name field name
*/
public void addReturnNamed(String name) {
ReturnStatement ret = m_ast.newReturnStatement();
ret.setExpression(m_ast.newSimpleName(name));
m_block.statements().add(ret);
}
/**
* Append a statement returning null.
*/
public void addReturnNull() {
ReturnStatement ret = m_ast.newReturnStatement();
ret.setExpression(m_ast.newNullLiteral());
m_block.statements().add(ret);
}
/**
* Append a throw new exception statement.
*
* @param type exception type
* @param text
*/
public void addThrowException(String type, String text) {
ThrowStatement thrwstmt = m_ast.newThrowStatement();
ClassInstanceCreation exexpr = m_ast.newClassInstanceCreation();
exexpr.setType(m_ast.newSimpleType(m_ast.newSimpleName(type)));
exexpr.arguments().add(stringLiteral(text));
thrwstmt.setExpression(exexpr);
m_block.statements().add(thrwstmt);
}
/**
* Append a throw new exception statement.
*
* @param type exception type
* @param expr initializer expression
*/
public void addThrowException(String type, ExpressionBuilderBase expr) {
ThrowStatement thrwstmt = m_ast.newThrowStatement();
ClassInstanceCreation exexpr = m_ast.newClassInstanceCreation();
exexpr.setType(m_ast.newSimpleType(m_ast.newSimpleName(type)));
exexpr.arguments().add(expr.getExpression());
thrwstmt.setExpression(exexpr);
m_block.statements().add(thrwstmt);
}
/**
* Append a method call statement.
*
* @param call
*/
public void addCall(InvocationBuilder call) {
m_block.statements().add(m_ast.newExpressionStatement(call.getExpression()));
}
/**
* Append a 'break' statement.
*/
public void addBreak() {
m_block.statements().add(m_ast.newBreakStatement());
}
/**
* Append a 'switch' statement using a local variable or field name as the switch value.
*
* @param name
* @return statement builder
*/
public SwitchBuilder addSwitch(String name) {
SwitchBuilder builder = new SwitchBuilder(m_source, m_ast.newSimpleName(name));
m_block.statements().add(builder.getStatement());
return builder;
}
/**
* Append a 'switch' statement using a constructed expression as the switch value.
*
* @param expr
* @return statement builder
*/
public SwitchBuilder addSwitch(ExpressionBuilderBase expr) {
SwitchBuilder builder = new SwitchBuilder(m_source, expr.getExpression());
m_block.statements().add(builder.getStatement());
return builder;
}
/**
* Append an expression statement.
*
* @param expr
*/
public void addExpressionStatement(ExpressionBuilderBase expr) {
m_block.statements().add(m_ast.newExpressionStatement(expr.getExpression()));
}
/**
* Append a constructed statement.
*
* @param stmt
*/
public void addStatement(StatementBuilderBase stmt) {
m_block.statements().add(stmt.getStatement());
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/TypeData.java 0000644 0001750 0001750 00000010172 11171722574 025101 0 ustar twerner twerner /*
* Copyright (c) 2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
/**
* Information for a class matching a schema definition.
*
* @author Dennis M. Sosnoski
*/
public class TypeData
{
/** Fully-qualified class name. */
private final String m_fullName;
/** Class name as used for binding (with '$' marker for inner class). */
private final String m_bindingName;
/** Pregenerated class flag. */
private final boolean m_pregenerated;
/** Class represents simple value flag. */
private final boolean m_simple;
/**
* Constructor with all values specified.
*
* @param fullname fully-qualified class name in standard form ('.' as inner class separator)
* @param bindname fully-qualified class name as used in binding (with '$' inner class separator)
* @param pregen pregenerated class flag
* @param simple simple value flag
*/
public TypeData(String fullname, String bindname, boolean pregen, boolean simple) {
m_fullName = fullname;
m_bindingName = bindname;
m_pregenerated = pregen;
m_simple = simple;
}
/**
* Constructor for new top-level class.
*
* @param fullname fully-qualified class name
* @param simple simple value flag
*/
public TypeData(String fullname, boolean simple) {
this(fullname, fullname, false, simple);
}
/**
* Constructor from new top-level or inner class.
*
* @param fullname fully-qualified class name in standard form ('.' as inner class separator)
* @param bindname fully-qualified class name as used in binding (with '$' inner class separator)
* @param simple simple value flag
*/
public TypeData(String fullname, String bindname, boolean simple) {
this(fullname, bindname, false, simple);
}
/**
* Get fully-qualified name.
*
* @return name
*/
public String getFullName() {
return m_fullName;
}
/**
* Get fully-qualified name as used in binding. This differs from the standard fully-qualified name in that it uses
* '$' rather than '.' to delimit inner class names.
*
* @return name
*/
public String getBindingName() {
return m_bindingName;
}
/**
* Check if pregenerated class.
*
* @return true if pregenerated, false if not
*/
public boolean isPregenerated() {
return m_pregenerated;
}
/**
* Check if class represents a simple value.
*
* @return true if simple value, false if not
*/
public boolean isSimpleValue() {
return m_simple;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/ClassHolder.java 0000644 0001750 0001750 00000164154 11424564100 025571 0 ustar twerner twerner /*
* Copyright (c) 2006-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.apache.log4j.Logger;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.jibx.binding.classes.ClassItem;
import org.jibx.binding.model.BindingHolder;
import org.jibx.binding.model.ElementBase;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.schema.INamed;
import org.jibx.schema.IReference;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.codegen.custom.ComponentExtension;
import org.jibx.schema.codegen.custom.NestingCustomBase;
import org.jibx.schema.codegen.custom.SchemaCustom;
import org.jibx.schema.codegen.custom.SchemaExtension;
import org.jibx.schema.codegen.extend.ClassDecorator;
import org.jibx.schema.codegen.extend.NameConverter;
import org.jibx.schema.elements.AnnotatedBase;
import org.jibx.schema.elements.AnnotationElement;
import org.jibx.schema.elements.AnnotationItem;
import org.jibx.schema.elements.DocumentationElement;
import org.jibx.schema.elements.FilteredSegmentList;
import org.jibx.schema.elements.OpenAttrBase;
import org.jibx.schema.elements.SchemaBase;
import org.jibx.util.LazyList;
import org.jibx.util.UniqueNameSet;
import org.w3c.dom.Node;
/**
* Information for a class to be included in code generated from schema.
*
* @author Dennis M. Sosnoski
*/
public abstract class ClassHolder extends TypeData implements IClassHolder
{
// collection constants
protected static final String COLLECTION_VARIABLE_TYPE = "java.util.List";
protected static final String COLLECTION_VARIABLE_NAME = "list";
// general definitions used in binding code generation
// protected static final String STATIC_UNMARSHAL_METHOD = "_unmarshal_if_present";
// protected static final String STRUCTURE_INTERFACE = "org.jibx.v2.MappedStructure";
// protected static final String MARSHAL_METHOD = "_marshal";
// protected static final String WRITER_TYPE = "org.jibx.v2.XmlWriter";
// protected static final String WRITER_VARNAME = "wrtr";
// protected static final String UNMARSHAL_METHOD = "_unmarshal";
// protected static final String QNAME_TYPE = "org.jibx.runtime.QName";
// protected static final String TYPE_INTERFACE = "org.jibx.v2.MappedType";
// protected static final String TYPE_NAME_METHOD = "_get_type_qname";
// protected static final String TYPE_NAME_VARIABLE = "_type_name";
// protected static final String ELEMENT_INTERFACE = "org.jibx.v2.MappedElement";
// protected static final String ELEMENT_NAME_METHOD = "_get_element_qname";
// protected static final String ELEMENT_NAME_VARIABLE = "_element_name";
// protected static final String INSTANCE_VARNAME = "inst";
// reader definitions
// protected static final String READER_TYPE = "org.jibx.v2.XmlReader";
// protected static final String READER_VARNAME = "rdr";
// protected static final String READER_CHECK_START_TAG_METHOD = "checkStartTag";
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(ClassHolder.class.getName());
/** Schema documentation generator. */
private static final SchemaDocumentationGenerator s_generator;
static {
try {
s_generator = new SchemaDocumentationGenerator();
} catch (JiBXException e) {
s_logger.fatal("Error loading schema extract binding", e);
throw new IllegalStateException("Internal error - error loading schema extract binding: " + e.getMessage());
}
}
/** Null transformer used to output text form of documentation. */
private static final Transformer s_transformer;
static {
try {
s_transformer = TransformerFactory.newInstance().newTransformer();
s_transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
} catch (TransformerConfigurationException e) {
s_logger.fatal("Error creating empty transformer", e);
throw new IllegalStateException("Internal error - error creating empty transformer: " + e.getMessage());
} catch (TransformerFactoryConfigurationError e) {
s_logger.fatal("Error creating empty transformer", e);
throw new IllegalStateException("Internal error - error creating empty transformer: " + e.getMessage());
}
}
//
// Private instance data.
/** Simple class name. */
private final String m_name;
/** Superclass to be extended as part of schema model (null if none). */
private TypeData m_superClass;
/** Superclass name to be extended if extension not required by model (null if none). */
private String m_superName;
/** Class generated flag. */
private boolean m_generated;
/** Builder for class. */
private ClassBuilder m_classBuilder;
/** Customizations for the schema containing the schema component matching this class. */
private SchemaCustom m_schemaCustom;
//
// Data shared with subclasses.
/** Package containing class. */
protected final PackageHolder m_package;
/** Holder for class binding definition. */
protected final BindingHolder m_holder;
/** Name conversion handler. */
protected final NameConverter m_nameConverter;
/** Base class name (for use when generating separate classes for nested structures). */
protected final String m_baseName;
/** Decorators to be called in order during class code generation. */
protected final ClassDecorator[] m_decorators;
/** Use inner classes for substructures flag. */
protected final boolean m_useInnerClasses;
/** Holders for inner classes defined within this class (null if an inner class). */
protected final LazyList m_inners;
/** Containing class (null if not an inner class). */
protected final ClassHolder m_outerClass;
/** Tracker for imports. */
protected final ImportsTracker m_importsTracker;
/** Class used for initializing list instances. */
protected String m_listImplClass = "java.util.ArrayList";
/** Value names used in class. */
protected UniqueNameSet m_nameSet;
/**
* Constructor.
*
* @param name class name
* @param base base class name
* @param pack package information
* @param holder binding holder
* @param nconv name converter
* @param decorators class decorators
* @param inner use inner classes for substructures
* @param simple simple value flag
*/
public ClassHolder(String name, String base, PackageHolder pack, BindingHolder holder, NameConverter nconv,
ClassDecorator[] decorators, boolean inner, boolean simple) {
super(buildName(name, pack), simple);
m_package = pack;
m_holder = holder;
m_nameConverter = nconv;
m_name = name;
m_baseName = base;
m_decorators = decorators;
m_useInnerClasses = inner;
m_importsTracker = new ImportsTracker(pack.getName());
m_outerClass = null;
m_inners = new LazyList();
m_nameSet = new UniqueNameSet();
m_nameSet.add(name);
m_importsTracker.addLocalType(name, getFullName());
}
/**
* Build fully-qualified class name
*
* @param name simple class name
* @param pack package information
* @return fully-qualified class name
*/
private static String buildName(String name, PackageHolder pack) {
StringBuffer buff = new StringBuffer();
buff.append(pack.getName());
if (buff.length() > 0) {
buff.append('.');
}
buff.append(name);
return buff.toString();
}
/**
* Constructor for creating a child inner class definition.
*
* @param name class name
* @param context parent class
* @param simple simple value flag
*/
protected ClassHolder(String name, ClassHolder context, boolean simple) {
super(context.getFullName() + '.' + name, context.getBindingName() + '$' + name, simple);
m_package = context.m_package;
m_holder = context.m_holder;
m_nameConverter = context.m_nameConverter;
m_name = name;
m_baseName = null;
m_decorators = context.m_decorators;
m_useInnerClasses = true;
m_importsTracker = context.m_importsTracker;
m_outerClass = context;
m_inners = new LazyList();
m_nameSet = new UniqueNameSet();
ClassHolder scan = this;
while (scan != null) {
m_nameSet.add(scan.getName());
scan = scan.m_outerClass;
}
m_importsTracker.addLocalType(name, getFullName());
m_package.addInnerClass(this);
}
/**
* Get the schema customization associated with root schema component matching this class.
*
* @return schema customization
*/
public SchemaCustom getSchemaCustom() {
return m_schemaCustom;
}
/**
* Extract schema documentation from an element. This just checks for an annotation element on the supplied
* element, and if found returns a text string consisting of the content of all documentation element(s). The
* returned documentation text is suitable for use as JavaDoc content, with any JavaDoc end sequences ('*' followed
* by '/') substituted with a space added.
*
* @param element
* @return content of documentation elements, or null if none
*/
protected String extractDocumentation(AnnotatedBase element) {
if (m_schemaCustom.isJavaDocDocumentation()) {
StringWriter writer = new StringWriter();
AnnotationElement anno = element.getAnnotation();
if (anno != null) {
FilteredSegmentList items = anno.getItemsList();
for (int i = 0; i < items.size(); i++) {
AnnotationItem item = (AnnotationItem)items.get(i);
if (item instanceof DocumentationElement) {
DocumentationElement doc = (DocumentationElement)item;
List contents = doc.getContent();
if (contents != null) {
for (Iterator iter = contents.iterator(); iter.hasNext();) {
Node node = (Node)iter.next();
DOMSource source = new DOMSource(node);
StreamResult result = new StreamResult(writer);
try {
s_transformer.transform(source, result);
} catch (TransformerException e) {
s_logger.error("Failed documentation output transformation", e);
}
}
}
}
}
}
StringBuffer buff = writer.getBuffer();
if (buff.length() > 0) {
// make sure there's no embedded comment end marker
int index = buff.length();
while ((index = buff.lastIndexOf("*/", index)) >= 0) {
buff.replace(index, index+2, "* /");
}
return buff.toString();
}
}
return null;
}
/**
* Describe the schema component associated with a node. If the component for the supplied node is a named element
* or attribute, this just returns a combination of the name and type of that component. Otherwise, it moves up the
* node tree until it finds a named element or attribute, terminating if any parent has more than one child. If it
* can't find an element or attribute name but does find a named type, it uses that type as the name. If all else
* fails, it just returns the type of the highest level component found.
*
* @param node
* @return name
*/
protected static String describe(DataNode node) {
DataNode current = node;
OpenAttrBase last;
String name = null;
String alttext = null;
do {
OpenAttrBase comp = current.getSchemaComponent();
last = comp;
if (comp instanceof INamed) {
String check = ((INamed)comp).getName();
if (check != null) {
int type = comp.type();
if (type == SchemaBase.ATTRIBUTE_TYPE || type == SchemaBase.ELEMENT_TYPE) {
name = check;
} else if (alttext == null) {
alttext = "'" + check + "' " + comp.name();
}
}
}
if (name == null && comp instanceof IReference) {
QName ref = ((IReference)comp).getRef();
if (ref != null) {
name = ref.getName();
}
}
if (name != null) {
return "'" + name + "' " + comp.name();
}
current = current.getParent();
} while (current != null && ((ParentNode)current).getChildren().size() == 1);
if (alttext == null) {
return last.name();
} else {
return alttext;
}
}
/**
* Derive group names from the containing group prefix and the simple name of the group.
*
* @param group
* @param container (null if none)
* @return name
*/
// static String deriveGroupName(GroupItem group, Group container) {
// String prefix = null;
// if (container != null) {
// prefix = group.getClassName();
// String prior = container.getPrefix();
// if (prior == null) {
// prefix = NameConverter.toNameLead(prefix);
// } else {
// prefix = prior + NameConverter.toNameWord(prefix);
// }
// prefix = container.uniqueChildPrefix(prefix);
// }
// return prefix;
// }
/**
* Import the type associated with an item, if not directly accessible
*
* @param value
*/
protected void importValueType(DataNode value) {
String type = value.getType();
if (type != null) {
while (type.endsWith("[]")) {
type = type.substring(0, type.length()-2);
}
if (!ClassItem.isPrimitive(type)) {
ClassHolder outer = this;
while (outer.m_outerClass != null) {
outer = outer.m_outerClass;
}
String topname = outer.getFullName();
if (!type.equals(topname) && (!type.startsWith(topname) || type.charAt(topname.length()) != '.')) {
m_importsTracker.addImport(type, false);
}
}
}
}
/**
* Convert an item structure to a class representation. Subclasses need to override this method for thie own
* handling, but should call the base class implementatino first to initialize the schema customization link.
*
* @param group item group
* @param bindhold associated binding definition holder
*/
public void buildDataStructure(GroupItem group, BindingHolder bindhold) {
m_schemaCustom = ((SchemaExtension)group.getSchemaComponent().getSchema().getExtension()).getCustom();
}
/**
* Get containing package.
*
* @return package
*/
public PackageHolder getPackage() {
return m_package;
}
/**
* Get simple name.
*
* @return name
*/
public String getName() {
return m_name;
}
/**
* Get containing class of inner class.
*
* @return outer containing class, or null if not an inner class
*/
public IClassHolder getOuterClass() {
return m_outerClass;
}
/**
* Get base class to be extended.
*
* @return base (null if none)
*/
public TypeData getSuperClass() {
return m_superClass;
}
/**
* Set superclass to be extended.
*
* @param sclas (null if none)
*/
public void setSuperClass(TypeData sclas) {
m_superClass = sclas;
if (sclas != null) {
boolean imported = m_importsTracker.addImport(sclas.getFullName(), false);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Set superclass of " + getFullName() + " to " + sclas.getFullName() +
(imported ? " (imported)" : ""));
}
}
}
/**
* Check if superclass is forced by schema model.
*
* @return true if superclass forced, false if not
*/
public boolean isSuperClassForced() {
return m_superClass != null;
}
/**
* Get name of base class to be extended.
*
* @return base (null if none)
*/
public String getSuperClassName() {
if (m_superClass == null) {
return m_superName;
} else {
return m_superClass.getFullName();
}
}
/**
* Set name of base class to be extended. This method can only be used if a superclass has not been forced by the
* schema model. It is always safe to use this method if {@link #getSuperClassName()} returns null.
*
* @param base fully-qualified class name of base class (null if none)
*/
public void setSuperClassName(String base) {
if (m_superClass == null) {
m_superName = base;
if (base != null) {
boolean imported = m_importsTracker.addImport(base, false);
if (s_logger.isDebugEnabled()) {
s_logger.debug("Set superclass of " + getFullName() + " to " + base +
(imported ? " (imported)" : ""));
}
}
} else {
throw new IllegalArgumentException("Error - superclass is forced by schema model and cannot be overridden");
}
}
/**
* Set name of list implementation class to be used for initializing instances.
*
* @param list fully-qualified class name of list implementation (non-null)
*/
public void setListImplementation(String list) {
if (list == null) {
throw new IllegalStateException("Internal error - list implementation class cannot be null");
} else {
m_listImplClass = list;
}
}
/**
* Check if the class has been generated. This should always be called before calling {@link
* #generate(boolean, SourceBuilder)}, in order to prevent multiple generation passes over the same class.
*
* @return true if generated, false if not
*/
public boolean isGenerated() {
return m_generated;
}
/**
* Get the builder for this class.
*
* @return builder
*/
protected ClassBuilder getBuilder() {
return m_classBuilder;
}
/**
* Get the interfaces implemented by this class.
*
* @return interface names
*/
public String[] getInterfaces() {
return m_classBuilder.getInterfaces();
}
/**
* Get imports information.
*
* @return imports
*/
public ImportsTracker getImports() {
return m_importsTracker;
}
/**
* Get the fields defined in this class.
*
* @return fields
*/
public FieldDeclaration[] getFields() {
return m_classBuilder.getFields();
}
/**
* Get the methods defined in this class.
*
* @return methods
*/
public MethodDeclaration[] getMethods() {
return m_classBuilder.getMethods();
}
/**
* Add import for class. If the requested import doesn't conflict with the current set it's added, otherwise it's
* ignored.
*
* @param fqname fully qualified class name
* @return true if added as import
*/
public boolean addImport(String fqname) {
return m_importsTracker.addImport(fqname, false);
}
/**
* Get the name to be used for a type. If the type has been imported this returns the short form of the name;
* otherwise it just returns the fully-qualified name.
*
* @param type fully qualified class name
* @return name
*/
public String getTypeName(String type) {
return m_importsTracker.getName(type);
}
/**
* Add an interface to this class definition.
*
* @param interf interface type
*/
public void addInterface(String interf) {
m_classBuilder.addInterface(interf);
}
/**
* Add separately-constructed field to this class definition.
*
* @param field
*/
public void addField(FieldDeclaration field) {
m_classBuilder.addField(field);
}
/**
* Add separately-constructed method declaration to this class definition.
*
* @param method
*/
public void addMethod(MethodDeclaration method) {
m_classBuilder.addMethod(method);
}
/**
* Add separately-constructed inner class declaration to this class definition.
*
* @param type
*/
public void addType(TypeDeclaration type) {
m_classBuilder.addType(type);
}
/**
* Get a sorted array of the field names and types defined in this class.
*
* @return sorted pairs
*/
public StringPair[] getSortedFields() {
return m_classBuilder.getSortedFields();
}
/**
* Initialize the class construction. This is a support method for use by subclasses, which handles common setup
* including superclass generation.
*
* @param verbose
* @param builder
* @param root data structure tree root node
*/
protected void initClass(boolean verbose, ClassBuilder builder, ParentNode root) {
// make sure the builder has been set
m_classBuilder = builder;
// call decorators for initialization processing
for (int i = 0; i < m_decorators.length; i++) {
m_decorators[i].start(this);
}
// include documentation and/or schema in class comment if enabled
StringBuffer buff = new StringBuffer();
GroupItem group = (GroupItem)root.getItem();
String text = root.getDocumentation();
if (text != null) {
buff.append(text);
}
if (m_schemaCustom.isSchemaFragmentDocumentation()) {
text = s_generator.generate(group, m_schemaCustom.isDeleteAnnotations());
if (text != null) {
if (buff.length() > 0) {
buff.append(SchemaDocumentationGenerator.COMMENT_LEAD_TEXT);
buff.append(SchemaDocumentationGenerator.COMMENT_LEAD_TEXT);
}
buff.append(text);
}
}
if (buff.length() > 0) {
m_classBuilder.addSourceComment(buff.toString());
}
// force generation of superclass, and include all names from that
// TODO: maintain separate name list for those which are public/protected, vs. private
if (m_superClass != null && !m_superClass.isPregenerated()) {
if (!m_superClass.isPregenerated()) {
ClassHolder superclas = (ClassHolder)m_superClass;
superclas.getPackage().generate(verbose, m_superClass, m_classBuilder.getAST());
m_nameSet.addAll(superclas.m_nameSet);
}
}
// set flag to avoid re-generation
m_generated = true;
}
/**
* Finish class construction. This is a support method for use by subclasses, which handles common completion
* processing
*
* @param binding binding definition component for this class
*/
protected void finishClass(ElementBase binding) {
for (int i = 0; i < m_decorators.length; i++) {
m_decorators[i].finish(binding, this);
}
String basename = getSuperClass() == null ? getSuperClassName() : getSuperClass().getFullName();
if (basename != null) {
m_classBuilder.setSuperclass(basename);
}
}
/**
* Generate any inner classes of this class.
*
* @param verbose
* @param builder class source file builder
*/
protected void generateInner(boolean verbose, SourceBuilder builder) {
for (int i = 0; i < m_inners.size(); i++) {
((ClassHolder)m_inners.get(i)).generate(verbose, builder);
}
}
/**
* Generate this class. Subclasses must implement this method to first do the appropriate setup and then call
* {@link #initClass(boolean, ClassBuilder, ParentNode)} before doing their own code generation.
*
* @param verbose
* @param builder class source file builder
*/
public abstract void generate(boolean verbose, SourceBuilder builder);
/**
* Information for a data structure component of a class definition. The class data structure is defined by a tree
* of these components, with the interior nodes of the tree representing groupings which may need to be reflected in
* the actual data representation and/or the constructed binding. Because of this difference in purpose different
* subclasses are used for the interior nodes vs. the leaf nodes.
*/
protected static abstract class DataNode
{
/** Maximum number of characters of documentation text to include in description. */
private static final int DESCRIPTION_DOCUMENTATION_LIMIT = 20;
/** Associated item. */
private final Item m_item;
/** Parent node (null if none defined, only allowed for root node of tree). */
private final ParentNode m_parent;
/** Element or attribute name flag. */
private final boolean m_named;
/** Flag for an optional item. */
private final boolean m_optional;
/** Flag for an ignored item. */
private final boolean m_ignored;
/** Flag for a collection item. */
private final boolean m_collection;
/** Documentation extracted from schema for this data node. */
private String m_documentation;
/** Value type name. */
private String m_type;
/** Selection property name for 'if' method construction (only used with group selectors, null if
no selector for group). */
private String m_selectPropName;
/** Selection constant name (only used with group selectors, null if no selector for group). */
private String m_selectConstName;
/** Property name for value (null if no property). Even interior nodes may have property names, in
the case of a choice between different alternatives. */
private String m_propName;
/** Field name for value (null if no field). */
private String m_fieldName;
/** Get-method name for value (null if no get-method). */
private String m_getMethodName;
/** Set-method name for value (null if no set-method). */
private String m_setMethodName;
/** Test-method name for value (null if no test-method). */
private String m_testMethodName;
/** Flag-method name for value (null if no flag-method). */
private String m_flagMethodName;
/**
* Constructor. This automatically links the newly constructed node to the parent node.
*
* @param item associated item
* @param parent parent node
*/
public DataNode(Item item, ParentNode parent) {
m_item = item;
m_parent = parent;
AnnotatedBase comp = item.getSchemaComponent();
int comptype = comp.type();
m_named = (comptype == SchemaBase.ATTRIBUTE_TYPE || comptype == SchemaBase.ELEMENT_TYPE) &&
((INamed)comp).getName() != null;
Item topmost = item.getTopmost();
boolean optional = topmost.isOptional();
if (parent != null && ((GroupItem)parent.getItem()).isInline() && !parent.isNamed()) {
optional = optional || parent.isOptional();
}
m_optional = optional;
m_ignored = item.isIgnored();
if (m_ignored) {
m_type = null;
m_collection = false;
} else {
boolean collection = topmost.isCollection();
if (item instanceof ValueItem) {
// value item will always be a primitive or wrapper value
JavaType jtype = ((ValueItem)item).getType();
m_type = jtype.getPrimitiveName();
if (m_type == null || topmost.isOptional() || topmost.isCollection() || parent.isCollection()) {
m_type = jtype.getClassName();
}
} else if (item instanceof ReferenceItem) {
// reference item as value will always be a reference to the definition class
m_type = ((ReferenceItem)item).getDefinition().getGenerateClass().getFullName();
} else if (item instanceof AnyItem) {
// xs:any handling determines value type
switch (item.getComponentExtension().getAnyType()) {
case NestingCustomBase.ANY_DISCARD:
m_type = null;
collection = false;
break;
case NestingCustomBase.ANY_DOM:
m_type = "org.w3c.dom.Element";
break;
case NestingCustomBase.ANY_MAPPED:
m_type = "java.lang.Object";
break;
default:
throw new IllegalStateException("Internal error - unknown xs:any handling");
}
} else if (!((GroupItem)item).isInline()) {
// group item as value will always be a reference to the group class
m_type = ((GroupItem)item).getGenerateClass().getFullName();
}
m_collection = collection;
}
if (parent != null) {
parent.addChild(this);
}
}
/**
* Adjust name based on group nesting.
* TODO: needs switch to control
*/
// public void adjustName() {
// if (!m_item.isFixedName() && m_container != null) {
// String prefix = m_container.getPrefix();
// if (prefix != null) {
// m_item.setName(prefix + NameConverter.toNameWord(m_item.getEffectiveName()));
// }
// }
// }
/**
* Get associated item.
*
* @return item
*/
public Item getItem() {
return m_item;
}
/**
* Get the associated schema component.
*
* @return component
*/
public AnnotatedBase getSchemaComponent() {
return m_item.getSchemaComponent();
}
/**
* Get parent node.
*
* @return parent
*/
public ParentNode getParent() {
return m_parent;
}
/**
* Check if this is an interior node. This method is overridden by each subclass to return the appropriate
* result.
*
* @return true if node with children, false if not
*/
public abstract boolean isInterior();
/**
* Check if value is ignored.
*
* @return ignored
*/
public boolean isIgnored() {
return m_ignored;
}
/**
* Check if value is optional.
*
* @return optional
*/
public boolean isOptional() {
return m_optional;
}
/**
* Check if a collection value.
*
* @return true if collection
*/
public boolean isCollection() {
return m_collection;
}
/**
* Check if an xs:list value.
*
* @return true if list
*/
public boolean isList() {
return m_item.getSchemaComponent().type() == SchemaBase.LIST_TYPE;
}
/**
* Check if an xs:any value.
*
* @return true if any
*/
public boolean isAny() {
return m_item.getSchemaComponent().type() == SchemaBase.ANY_TYPE;
}
/**
* Check if a name (element or attribute) is associated with this node.
*
* @return true if named
*/
public boolean isNamed() {
return m_named;
}
/**
* Get the name associated with a node.
*
* @return name, or null if none
*/
public QName getQName() {
if (m_named) {
return ((INamed)m_item.getSchemaComponent()).getQName();
} else {
return null;
}
}
/**
* Check if a reference (element or attribute) is associated with this node.
*
* @return true if named
*/
public boolean isReference() {
AnnotatedBase comp = m_item.getSchemaComponent();
return comp instanceof IReference && ((IReference)comp).getRef() != null;
}
/**
* Get the reference name associated with a node.
*
* @return reference name, or null if none
*/
public QName getReferenceQName() {
AnnotatedBase comp = m_item.getSchemaComponent();
if (comp instanceof IReference) {
return ((IReference)comp).getRef();
} else {
return null;
}
}
/**
* Get schema documentation for this node.
*
* @return documentation
*/
public String getDocumentation() {
return m_documentation;
}
/**
* Set schema documentation for this node.
*
* @param text
*/
public void setDocumentation(String text) {
m_documentation = text;
}
/**
* Get the value type name.
*
* @return type (null if no type associated with value, only on group)
*/
public String getType() {
return m_type;
}
/**
* Get the value type name in binding form. For an object type, this differs from the standard fully-qualified
* name in that it uses '$' rather than '.' to delimit inner class names.
*
* @return binding type (null if no type associated with value, only on group)
*/
public String getBindingType() {
if (m_item instanceof ReferenceItem) {
return ((ReferenceItem)m_item).getDefinition().getGenerateClass().getBindingName();
} else {
if (m_item instanceof GroupItem) {
TypeData genclass = ((GroupItem)m_item).getGenerateClass();
if (genclass != null) {
return genclass.getBindingName();
}
}
return m_type;
}
}
/**
* Get selection property name (used for 'if' method generation). This is only used with group selectors, and is
* null if the containing group does not use a selector.
*
* @return name (null if no selector for group)
*/
public String getSelectPropName() {
return m_selectPropName;
}
/**
* Set selection property name (used for 'if' method generation). This is only used with group selectors.
*
* @param name (null if no selector for group)
*/
public void setSelectPropName(String name) {
m_selectPropName = name;
}
/**
* Get selection constant name. This is only used with group selectors, and is null if the
* containing group does not use a selector.
*
* @return name (null if no selector for group)
*/
public String getSelectConstName() {
return m_selectConstName;
}
/**
* Set selection constant name. This is only used with group selectors.
*
* @param name (null if no selector for group)
*/
public void setSelectConstName(String name) {
m_selectConstName = name;
}
/**
* Get property name for value.
*
* @return name (null if none)
*/
public String getPropName() {
return m_propName;
}
/**
* Set property name for value.
*
* @param name name (null if none)
*/
public void setPropName(String name) {
m_propName = name;
}
/**
* Get field name used for value.
*
* @return name (null if no field)
*/
public String getFieldName() {
return m_fieldName;
}
/**
* Set field name used for value.
*
* @param name (null if no field)
*/
public void setFieldName(String name) {
m_fieldName = name;
}
/**
* Get get-method name used for value.
*
* @return name (null if no get-method)
*/
public String getGetMethodName() {
return m_getMethodName;
}
/**
* Set get-method name used for value.
*
* @param name (null if no get-method)
*/
public void setGetMethodName(String name) {
m_getMethodName = name;
}
/**
* Get set-method name used for value.
*
* @return name (null if no set-method)
*/
public String getSetMethodName() {
return m_setMethodName;
}
/**
* Set set-method name used for value.
*
* @param name (null if no set-method)
*/
public void setSetMethodName(String name) {
m_setMethodName = name;
}
/**
* Get test-method name used for value.
*
* @return name (null if no set-method)
*/
public String getTestMethodName() {
return m_testMethodName;
}
/**
* Set test-method name used for value.
*
* @param name (null if no set-method)
*/
public void setTestMethodName(String name) {
m_testMethodName = name;
}
/**
* Get flag-method name used for value.
*
* @return name (null if no set-method)
*/
public String getFlagMethodName() {
return m_flagMethodName;
}
/**
* Set flag-method name used for value.
*
* @param name (null if no flag-method)
*/
public void setFlagMethodName(String name) {
m_flagMethodName = name;
}
/**
* Generate the node description.
*
* @param depth current nesting depth
* @return description
*/
public abstract String describe(int depth);
/**
* Append documentation text to description. This appends a potentially truncated version of the documentation
* for the component to the description text under construction, also trimming whitespace and replacing line
* breaks with pipe characters to keep the description text to a single line.
*
* @param buff
*/
protected void appendDocText(StringBuffer buff) {
String doctext = getDocumentation();
if (doctext != null) {
buff.append(" (");
if (doctext.length() > DESCRIPTION_DOCUMENTATION_LIMIT) {
doctext = doctext.substring(0, DESCRIPTION_DOCUMENTATION_LIMIT) + "...";
}
doctext = doctext.trim().replace('\n', '|').replace('\r', '|');
buff.append(doctext);
buff.append(')');
}
}
/**
* Append selection constant text to description, if selection constant defined.
*
* @param buff
*/
protected void appendSelectConstText(StringBuffer buff) {
if (getSelectConstName() != null) {
buff.append(" (selection ");
buff.append(getSelectConstName());
buff.append(')');
}
}
}
/**
* Information for a leaf node of the data structure tree.
*/
protected static class LeafNode extends DataNode
{
/**
* Constructor. This automatically links to the containing node.
*
* @param item
* @param parent
*/
public LeafNode(Item item, ParentNode parent) {
super(item, parent);
}
/**
* Check if this is an interior node (always false).
*
* @return false for value component
*/
public boolean isInterior() {
return false;
}
/**
* Generate the node description.
*
* @param depth current nesting depth
* @return description
*/
public String describe(int depth) {
StringBuffer buff = new StringBuffer(depth + 40);
buff.append(SchemaUtils.getIndentation(depth));
if (isOptional()) {
buff.append("optional ");
}
if (isIgnored()) {
buff.append("ignored ");
}
if (isCollection()) {
buff.append("collection ");
}
buff.append("leaf ");
buff.append(getItem().getName());
if (getFieldName() != null) {
buff.append(" field ");
buff.append(getFieldName());
buff.append(" of type ");
buff.append(getType());
}
buff.append(" for schema component ");
buff.append(SchemaUtils.describeComponent(getItem().getSchemaComponent()));
appendSelectConstText(buff);
appendDocText(buff);
return buff.toString();
}
}
/**
* Information for an interior node of the data structure tree. Depending on the type of the associated schema
* component a selector field may be used to track which of a set of alternatives is actually present.
*/
protected static class ParentNode extends DataNode
{
/** Type of selector handling needed for group. Selector fields are used with mutually exclusive
alternatives. The values are based on {@link NestingCustomBase#SELECTION_UNCHECKED} and alternatives. */
private final int m_selectorType;
/** Selection state exposed to user flag. */
private final boolean m_selectorExposed;
/** Prefix for all contained value names (null if none used). */
private final String m_prefix;
/** Values in this group. */
private final ArrayList m_values;
/** Flag for a collection node that wraps some other structure (rather than a simple leaf node). */
private boolean m_complexCollection;
/** Field name for selector */
private String m_selectField;
/** Method name for selection check method. */
private String m_selectCheckMethod;
/** Method name for selection set method. */
private String m_selectSetMethod;
/** Flag for selection requirement checked. */
private boolean m_selectChecked;
/** Flag for selection needed. */
private boolean m_selectNeeded;
/**
* Constructor. This derives the prefix used for all contained value names by appending the class name set for
* this group to the prefix used for the containing group.
*
* @param group associated item group
* @param parent containing node
*/
public ParentNode(GroupItem group, ParentNode parent) {
super(group, parent);
// TODO: this really should be a separate pass to handle fixed class names
String prefix = NameUtils.toNameWord(group.getEffectiveClassName());
m_prefix = prefix;
int select = NestingCustomBase.SELECTION_UNCHECKED;
boolean exposed = false;
ComponentExtension extension = group.getComponentExtension();
switch (group.getSchemaComponent().type()) {
case SchemaBase.CHOICE_TYPE:
select = extension.getChoiceType();
exposed = extension.isChoiceExposed();
break;
case SchemaBase.UNION_TYPE:
select = extension.getUnionType();
exposed = extension.isUnionExposed();
break;
}
if (select != NestingCustomBase.SELECTION_UNCHECKED) {
// no selector needed if handled by parent, or if no choices
if ((parent != null && parent.getSchemaComponent() == group.getSchemaComponent()) ||
group.getChildCount() <= 1) {
select = NestingCustomBase.SELECTION_UNCHECKED;
exposed = false;
}
}
m_selectorType = select;
m_selectorExposed = exposed;
m_values = new ArrayList();
}
/**
* Check if this is an interior node (always true).
*
* @return true for structure component
*/
public boolean isInterior() {
return true;
}
/**
* Check if a selector field is required for this group.
*
* @return selector
*/
public boolean isSelectorNeeded() {
if (!m_selectChecked) {
if (m_selectorType != NestingCustomBase.SELECTION_UNCHECKED) {
// before reporting selector needed, make sure at least once child is going to be present
for (int i = 0; i < m_values.size(); i++) {
DataNode node = (DataNode)m_values.get(i);
if (!node.isIgnored()) {
m_selectNeeded = true;
break;
}
}
}
m_selectChecked = true;
}
return m_selectNeeded;
}
/**
* Check if a selector field may be required for this group.
*
* @return selector
*/
public boolean isSelectorType() {
return m_selectorType != NestingCustomBase.SELECTION_UNCHECKED;
}
/**
* Get the selector type.
*
* @return type
*/
public int getSelectorType() {
return m_selectorType;
}
/**
* Check if selector state should be exposed to user.
*
* @return selector
*/
public boolean isSelectorExposed() {
return m_selectorExposed;
}
/**
* Adjust name based on group nesting. This has special handling for the case of <sequence> compositors,
* substituting the name of the first value in the sequence for the value name if a fixed name has not been
* assigned to the sequence.
*/
public void adjustName() {
Item item = getItem();
if (!item.isFixedName()) {
if (item.getSchemaComponent().type() == SchemaBase.SEQUENCE_TYPE) {
if (m_values.size() > 0) {
Item childitem = ((DataNode)m_values.get(0)).getItem();
if (item != childitem) {
item.setName(childitem.getEffectiveName());
}
}
}
}
}
/**
* Get prefix for value names in group.
*
* @return prefix (null if none used)
*/
public String getPrefix() {
return m_prefix;
}
/**
* Add a child node (which may be another parent) to this parent. This method is normally only used by the
* superclass, when creating a new instance. The instance must be fully initialized before it is added.
*
* @param value
*/
protected void addChild(DataNode value) {
m_values.add(value);
if (isCollection()) {
// make this a complex collection if the added child is something more than a simple value
if (value.getSchemaComponent() != getSchemaComponent() &&
value.isInterior() || value.isCollection()) {
m_complexCollection = true;
}
}
}
/**
* Get child nodes of this parent. The returned list is "live", but should never be modified.
*
* @return values
*/
public ArrayList getChildren() {
return m_values;
}
/**
* Check if this is a collection that wraps some other structure (rather than a simple leaf node).
*
* @return true if wrapper collection
*/
public boolean isComplexCollection() {
return m_complexCollection;
}
/**
* Get selector field name.
*
* @return name (null if no selector for group)
*/
public String getSelectField() {
return m_selectField;
}
/**
* Set selector field name.
*
* @param name (null if no selector for group)
*/
public void setSelectField(String name) {
m_selectField = name;
}
/**
* Get selector set method name.
*
* @return name (null if no selector set method for group)
*/
public String getSelectSetMethod() {
return m_selectSetMethod;
}
/**
* Set selector set method name.
*
* @param name (null if no selector set method for group)
*/
public void setSelectSetMethod(String name) {
m_selectSetMethod = name;
}
/**
* Get selector check method name.
*
* @return name (null if no selector check method for group)
*/
public String getSelectCheckMethod() {
return m_selectCheckMethod;
}
/**
* Set selector check method name.
*
* @param name (null if no selector check method for group)
*/
public void setSelectCheckMethod(String name) {
m_selectCheckMethod = name;
}
/**
* Generate the subtree description.
*
* @param depth current nesting depth
* @return description
*/
public String describe(int depth) {
StringBuffer buff = new StringBuffer(depth + 40);
buff.append(SchemaUtils.getIndentation(depth));
if (isOptional()) {
buff.append("optional ");
}
if (isIgnored()) {
buff.append("ignored ");
}
if (isCollection()) {
if (isComplexCollection()) {
buff.append("complex ");
}
buff.append("collection ");
}
buff.append("node ");
buff.append(getItem().getName());
buff.append(" for schema component ");
buff.append(SchemaUtils.describeComponent(getItem().getSchemaComponent()));
if (getFieldName() != null) {
buff.append(" field ");
buff.append(getFieldName());
buff.append(" of type ");
buff.append(getType());
}
if (m_selectorType != NestingCustomBase.SELECTION_UNCHECKED) {
buff.append(" (with selector)");
}
appendSelectConstText(buff);
appendDocText(buff);
for (int i = 0; i < m_values.size(); i++) {
buff.append('\n');
DataNode value = (DataNode)m_values.get(i);
buff.append(value.describe(depth+1));
}
return buff.toString();
}
}
/**
* Builder for an unmarshalling presence test method. This is based around the structure of a schema sequence, which
* may have any number of mixed required and optional elements. The presence test checks if the current element name
* matches one of those in the sequence up to and including the first required element name.
*/
// private class UnmarshalPresenceTestBuilder
// {
// /** Builder for the logical or expression. */
// private final InfixExpressionBuilder m_expression;
//
// /** Implicit namespace in use at point of evaluation. */
// private final String m_implicitNamespace;
//
// /** Expression completed flag (set when a required element is added to expression). */
// private boolean m_complete;
//
// /**
// * Constructor.
// *
// * @param implns implicit namespace in use at point of evaluation
// */
// public UnmarshalPresenceTestBuilder(String implns) {
// m_expression = m_classBuilder.buildInfix(Operator.OR);
// m_implicitNamespace = implns;
// }
//
// /**
// * Add an element to the presence test expression. If the expression is already complete (with a required
// * element found), the call is ignored.
// *
// * @param ns
// * @param name
// * @param required
// */
// public void addElement(String ns, String name, boolean required) {
// if (!m_complete) {
// InvocationBuilder call = m_classBuilder.createNormalMethodCall(READER_VARNAME,
// READER_CHECK_START_TAG_METHOD);
// if ((m_implicitNamespace == null && ns != null) ||
// (m_implicitNamespace != null && !m_implicitNamespace.equals(ns))) {
// call.addStringLiteralOperand(ns);
// }
// call.addStringLiteralOperand(name);
// m_expression.addOperand(call);
// if (required) {
// m_complete = true;
// }
// }
// }
//
// /**
// * Get the expression.
// *
// * @return expression
// */
// public InfixExpressionBuilder getExpression() {
// return m_expression;
// }
// }
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/SwitchBuilder.java 0000644 0001750 0001750 00000013661 11002543774 026140 0 ustar twerner twerner /*
* Copyright (c) 2007-2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen;
import java.util.List;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.Statement;
import org.eclipse.jdt.core.dom.SwitchCase;
import org.eclipse.jdt.core.dom.SwitchStatement;
/**
* Switch statement builder. This wraps the AST switch representation with convenience methods and added control
* information.
*
* @author Dennis M. Sosnoski
*/
public class SwitchBuilder extends StatementBuilderBase
{
/** Method invocation. */
private final SwitchStatement m_switch;
/**
* Constructor.
*
* @param source
* @param expr expression
*/
public SwitchBuilder(ClassBuilder source, Expression expr) {
super(source);
m_switch = source.getAST().newSwitchStatement();
m_switch.setExpression(expr);
}
/**
* Get the statement.
*
* @return statement
*/
Statement getStatement() {
return m_switch;
}
/**
* Check if a break statement is needed following the statement for a particular case.
*
* @param stmt
* @return true if break needed, false if not
*/
private static boolean isBreakNeeded(Statement stmt) {
switch (stmt.getNodeType()) {
case ASTNode.BLOCK:
{
List stmts = ((Block)stmt).statements();
int size = stmts.size();
if (size == 0) {
return true;
} else {
return isBreakNeeded((Statement)stmts.get(size-1));
}
}
case ASTNode.RETURN_STATEMENT:
case ASTNode.THROW_STATEMENT:
return false;
default:
return true;
}
}
/**
* Add case to switch statement with a named constant as the match value.
*
* @param name named constant
* @param stmt statement to be executed
*/
public void addNamedCase(String name, StatementBuilderBase stmt) {
SwitchCase swcase = m_ast.newSwitchCase();
swcase.setExpression(m_ast.newSimpleName(name));
m_switch.statements().add(swcase);
m_switch.statements().add(stmt.getStatement());
if (isBreakNeeded(stmt.getStatement())) {
m_switch.statements().add(m_ast.newBreakStatement());
}
}
/**
* Add case to switch statement with a number as the match value.
*
* @param value match value
* @param stmt statement to be executed
*/
public void addNumberCase(String value, StatementBuilderBase stmt) {
SwitchCase swcase = m_ast.newSwitchCase();
swcase.setExpression(numberLiteral(value));
m_switch.statements().add(swcase);
m_switch.statements().add(stmt.getStatement());
if (isBreakNeeded(stmt.getStatement())) {
m_switch.statements().add(m_ast.newBreakStatement());
}
}
/**
* Add default case to switch statement.
*
* @param stmt statement to be executed
*/
public void addDefault(StatementBuilderBase stmt) {
SwitchCase swcase = m_ast.newSwitchCase();
m_switch.statements().add(swcase);
m_switch.statements().add(stmt.getStatement());
if (isBreakNeeded(stmt.getStatement())) {
m_switch.statements().add(m_ast.newBreakStatement());
}
}
/**
* Add case to switch statement with new block for case code.
*
* @param expr
* @return block
*/
private BlockBuilder newCaseBlock(Expression expr) {
SwitchCase swcase = m_ast.newSwitchCase();
swcase.setExpression(expr);
m_switch.statements().add(swcase);
BlockBuilder block = m_source.newBlock();
m_switch.statements().add(block.getStatement());
return block;
}
/**
* Add case to switch statement with returned block for code.
*
* @param name named constant
* @return block
*/
public BlockBuilder newNamedCase(String name) {
return newCaseBlock(m_ast.newSimpleName(name));
}
/**
* Add case to switch statement with returned block for code.
*
* @param value match value
* @return block
*/
public BlockBuilder newNumberCase(String value) {
return newCaseBlock(numberLiteral(value));
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/extend/ 0000755 0001750 0001750 00000000000 11526304016 024000 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/extend/ClassDecorator.java 0000644 0001750 0001750 00000006105 11157776774 027605 0 ustar twerner twerner /*
* Copyright (c) 2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.extend;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.jibx.binding.model.ElementBase;
import org.jibx.schema.codegen.IClassHolder;
/**
* Interface implemented by class construction decorators used during code generation.
*
* @author Dennis M. Sosnoski
*/
public interface ClassDecorator
{
/**
* Method called before starting code generation for the target class.
*
* @param holder
*/
void start(IClassHolder holder);
/**
* Method called after adding each data value to class.
*
* @param basename base name used for data value
* @param collect repeated value flag
* @param type value type (item value type, in the case of a repeated value)
* @param field actual field
* @param getmeth read access method (null if a flag value)
* @param setmeth write access method (null if a flag value)
* @param descript value description text
* @param holder
*/
void valueAdded(String basename, boolean collect, String type, FieldDeclaration field, MethodDeclaration getmeth,
MethodDeclaration setmeth, String descript, IClassHolder holder);
/**
* Method called after completing code generation for the target class.
*
* @param binding binding definition element for class, a <format> if the class is an enumeration, a <mapping>
* or <structure> if it's a normal class
* @param holder
*/
void finish(ElementBase binding, IClassHolder holder);
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/extend/ExtensionDecorator.java 0000644 0001750 0001750 00000012304 11175604004 030462 0 ustar twerner twerner /*
* Copyright (c) 2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.extend;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.jibx.binding.model.ContainerElementBase;
import org.jibx.binding.model.ElementBase;
import org.jibx.schema.codegen.IClassHolder;
/**
* Code generation decorator which matches on the generated class name, and when it finds a matching class it sets a
* superclass. This also supports setting several of the object attributes on the binding element for the class (which
* must be a normal data class, rather than an enumeration).
*/
public class ExtensionDecorator extends NameMatchDecoratorBase
{
/** Base class to be set for matched classes. */
private String m_baseClass;
/** Name of method to be called after an instance of class is unmarshalled (null if none). */
private String m_postSetName;
/** Name of method to be called before an instance of class is unmarshalled (null if none). */
private String m_preSetName;
/** Name of method to be called before an instance of class is marshalled (null if none). */
private String m_preGetName;
/**
* Set base class to be set for matched classes.
*
* @param name
*/
public void setBaseClass(String name) {
m_baseClass = name;
}
/**
* Set name of method to be called after an instance of class is unmarshalled.
*
* @param name
*/
public void setPostSet(String name) {
m_postSetName = name;
}
/**
* Set name of method to be called before an instance of class is unmarshalled.
*
* @param name
*/
public void setPreSet(String name) {
m_preSetName = name;
}
/**
* Set name of method to be called before an instance of class is marshalled.
*
* @param name
*/
public void setPreGet(String name) {
m_preGetName = name;
}
/**
* Method called after completing code generation for the target class. This sets the object attributes, if needed.
*
* @param binding
* @param holder
*/
public void finish(ElementBase binding, IClassHolder holder) {
if (matchName(holder.getName()) && (m_postSetName != null || m_preSetName != null || m_preGetName != null)) {
if (binding instanceof ContainerElementBase) {
ContainerElementBase contain = (ContainerElementBase)binding;
contain.setPostsetName(m_postSetName);
contain.setPresetName(m_preSetName);
contain.setPregetName(m_preGetName);
} else {
throw new IllegalStateException("Class " + holder.getFullName() + " is not a data class");
}
}
}
/**
* Method called before starting code generation for the target class. This just sets the superclass.
*
* @param holder
*/
public void start(IClassHolder holder) {
if (matchName(holder.getName())) {
holder.setSuperClassName(m_baseClass);
}
}
/**
* Method called after adding each data value to class. Unused for this decorator.
*
* @param basename base name used for data value
* @param collect repeated value flag
* @param type value type (item value type, in the case of a repeated value)
* @param field actual field
* @param getmeth read access method
* @param setmeth write access method
* @param descript value description text
* @param holder
*/
public void valueAdded(String basename, boolean collect, String type, FieldDeclaration field,
MethodDeclaration getmeth, MethodDeclaration setmeth, String descript, IClassHolder holder) {}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/extend/SerializableDecorator.java 0000644 0001750 0001750 00000010321 11157776774 031141 0 ustar twerner twerner /*
* Copyright (c) 2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.extend;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.jibx.binding.model.ElementBase;
import org.jibx.schema.codegen.IClassHolder;
/**
* Code generation decorator which adds the java.lang.Serializable interface to each class, and optionally
* also adds a private static final long serialVersionUID value.
*/
public class SerializableDecorator implements ClassDecorator
{
/** Parser instance used by class. */
private final ASTParser m_parser = ASTParser.newParser(AST.JLS3);
/** Serial version UID value (null if not set). */
private Long m_serialVersion;
/**
* Set serial version.
*
* @param version
*/
public void setSerialVersion(Long version) {
m_serialVersion = version;
}
/**
* Method called after completing code generation for the target class.
*
* @param binding
* @param holder
*/
public void finish(ElementBase binding, IClassHolder holder) {}
/**
* Method called before starting code generation for the target class.
*
* @param holder
*/
public void start(IClassHolder holder) {
holder.addImport("java.io.Serializable");
holder.addInterface("java.io.Serializable");
if (m_serialVersion != null) {
// parse class text to get field declaration
String text = "class gorph { private static final long serialVersionUID = " + m_serialVersion + "; }";
m_parser.setSource(text.toCharArray());
CompilationUnit unit = (CompilationUnit)m_parser.createAST(null);
TypeDeclaration type = (TypeDeclaration)unit.types().get(0);
FieldDeclaration field = (FieldDeclaration)type.bodyDeclarations().get(0);
holder.addField(field);
}
}
/**
* Method called after adding each data value to class.
*
* @param basename base name used for data value
* @param collect repeated value flag
* @param type value type (item value type, in the case of a repeated value)
* @param field actual field
* @param getmeth read access method
* @param setmeth write access method
* @param descript value description text
* @param holder
*/
public void valueAdded(String basename, boolean collect, String type, FieldDeclaration field,
MethodDeclaration getmeth, MethodDeclaration setmeth, String descript, IClassHolder holder) {}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/extend/DefaultNameConverter.java 0000644 0001750 0001750 00000050372 11365564754 030751 0 ustar twerner twerner /*
* Copyright (c) 2006-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.extend;
import java.util.ArrayList;
import org.jibx.schema.codegen.NameUtils;
import org.jibx.util.NameUtilities;
/**
* Converter for working with Java names.
*
* @author Dennis M. Sosnoski
*/
public class DefaultNameConverter implements NameConverter
{
/** Camelcase field names flag. */
private boolean m_camelCase;
/** Prefix used for normal field names (non-null, may be empty). */
private String m_fieldPrefix;
/** Suffix used for normal field names (non-null, may be empty). */
private String m_fieldSuffix;
/** Prefix used for static field names (non-null, may be empty). */
private String m_staticPrefix;
/** Suffix used for static field names (non-null, may be empty). */
private String m_staticSuffix;
/** Use underscores in field names flag (as substitute for special characters, and to split words). */
private boolean m_underscore;
/** Uppercase initial letter of field names flag. */
private boolean m_upperInitial;
/** Set of XML name prefixes to be discarded in conversions. */
private String[] m_stripPrefixes;
/** Set of XML name suffixes to be discarded in conversions. */
private String[] m_stripSuffixes;
/** Reusable array for words in name. */
private ArrayList m_wordList;
/**
* Constructor.
*/
public DefaultNameConverter() {
m_fieldPrefix = "";
m_fieldSuffix = "";
m_staticPrefix = "";
m_staticSuffix = "";
m_camelCase = true;
m_stripPrefixes = m_stripSuffixes = new String[0];
m_wordList = new ArrayList();
}
/**
* Copy constructor.
*
* @param base instance used to initialize settings
*/
public DefaultNameConverter(DefaultNameConverter base) {
m_fieldPrefix = base.m_fieldPrefix;
m_fieldSuffix = base.m_fieldSuffix;
m_staticPrefix = base.m_staticPrefix;
m_staticSuffix = base.m_staticSuffix;
m_camelCase = base.m_camelCase;
m_stripPrefixes = base.m_stripPrefixes;
m_stripSuffixes = base.m_stripSuffixes;
m_wordList = new ArrayList();
}
/**
* Convert singular name to plural form.
*
* @param name base name
* @return plural name
*/
public String pluralize(String name) {
return NameUtilities.pluralize(name);
}
/**
* Convert potentially plural name to singular form.
*
* @param name base name
* @return singularized name
*/
public String depluralize(String name) {
return NameUtilities.depluralize(name);
}
/**
* Get prefix text for normal field names.
*
* @return field prefix (non-null, may be empty)
*/
public String getFieldPrefix() {
return m_fieldPrefix;
}
/**
* Set prefix text for normal field names.
*
* @param pref field prefix (non-null, may be empty)
*/
public void setFieldPrefix(String pref) {
m_fieldPrefix = pref;
}
/**
* Get suffix text for normal field names.
*
* @return field suffix (non-null, may be empty)
*/
public String getFieldSuffix() {
return m_fieldPrefix;
}
/**
* Set suffix text for normal field names.
*
* @param suff field suffix (non-null, may be empty)
*/
public void setFieldSuffix(String suff) {
m_fieldPrefix = suff;
}
/**
* Get prefix text for static field names.
*
* @return field prefix (non-null, may be empty)
*/
public String getStaticPrefix() {
return m_staticPrefix;
}
/**
* Set prefix text for static field names.
*
* @param pref field prefix (non-null, may be empty)
*/
public void setStaticPrefix(String pref) {
m_staticPrefix = pref;
}
/**
* Get suffix text for static field names.
*
* @return field suffix (non-null, may be empty)
*/
public String getStaticSuffix() {
return m_staticPrefix;
}
/**
* Set suffix text for static field names.
*
* @param suff field suffix (non-null, may be empty)
*/
public void setStaticSuffix(String suff) {
m_staticPrefix = suff;
}
/**
* Get the prefixes to be stripped when converting XML names.
*
* @return prefixes
*/
public String[] getStripPrefixes() {
return m_stripPrefixes;
}
/**
* Set the prefixes to be stripped when converting XML names.
*
* @param prefixes
*/
public void setStripPrefixes(String[] prefixes) {
m_stripPrefixes = prefixes;
}
/**
* Get the suffixes to be stripped when converting XML names.
*
* @return suffixes
*/
public String[] getStripSuffixes() {
return m_stripSuffixes;
}
/**
* Set the suffixes to be stripped when converting XML names.
*
* @param suffixes
*/
public void setStripSuffixes(String[] suffixes) {
m_stripSuffixes = suffixes;
}
/**
* Trim specified prefixes and/or suffixes from an XML name.
*
* @param xname XML name
* @return trimmed name, with specified prefixes and/or suffixes removed
*/
public String trimXName(String xname) {
// first trim off a prefix on name
for (int i = 0; i < m_stripPrefixes.length; i++) {
String prefix = m_stripPrefixes[i];
if (xname.startsWith(prefix) && xname.length() > prefix.length()) {
xname = xname.substring(prefix.length());
break;
}
}
// next trim off a suffix on name
for (int i = 0; i < m_stripSuffixes.length; i++) {
String suffix = m_stripSuffixes[i];
if (xname.endsWith(suffix) && xname.length() > suffix.length()) {
xname = xname.substring(0, xname.length() - suffix.length());
break;
}
}
return xname;
}
/**
* Split an XML name into words. This splits first on the basis of separator characters ('.', '-', and '_') in the
* name, and secondly based on case (an uppercase character immediately followed by one or more lowercase characters
* is considered a word, and multiple uppercase characters not followed immediately by a lowercase character are
* also considered a word). Characters which are not valid as parts of identifiers in Java are dropped from the XML
* name before it is split, and words starting with initial uppercase characters have the upper case dropped for
* consistency. Note that this method is not threadsafe.
*
* @param name
* @return array of words
*/
public String[] splitXMLWords(String name) {
// start by finding a valid start character
int offset = 0;
while (!Character.isJavaIdentifierStart(name.charAt(offset))) {
if (++offset >= name.length()) {
return new String[0];
}
}
// accumulate the list of words
StringBuffer word = new StringBuffer();
m_wordList.clear();
boolean lastupper = false;
while (offset < name.length()) {
// check next character of name
char chr = name.charAt(offset++);
if (chr == '-' || chr == '.' || chr == '_') {
// force split at each splitting character
if (word.length() > 0) {
m_wordList.add(word.toString());
word.setLength(0);
}
} else if (Character.isJavaIdentifierPart(chr)) {
// check case of valid identifier part character
if (Character.isUpperCase(chr)) {
if (!lastupper && word.length() > 0) {
// upper after lower, split before upper
m_wordList.add(word.toString());
word.setLength(0);
}
lastupper = true;
} else {
if (lastupper) {
if (word.length() > 1) {
// multiple uppers followed by lower, split before last
int split = word.length() - 1;
m_wordList.add(word.substring(0, split));
char start = Character.toLowerCase(word.charAt(split));
word.setLength(0);
word.append(start);
} else if (word.length() > 0) {
// single upper followed by lower, convert upper to lower
word.setCharAt(0, Character.toLowerCase(word.charAt(0)));
}
}
lastupper = false;
}
word.append(chr);
}
}
if (word.length() > 0) {
m_wordList.add(word.toString());
}
// return array of words
return (String[])m_wordList.toArray(new String[m_wordList.size()]);
}
/**
* Check if a name needs to be converted from XML form due to invalid characters or embedded underscores.
*
* @param name
* @return true if invalid name, false if valid
*/
protected static boolean isConversionNeeded(String name) {
int length = name.length();
if (length > 0) {
if (Character.isJavaIdentifierStart(name.charAt(0))) {
for (int i = 1; i < length; i++) {
char chr = name.charAt(i);
if (chr == '_' || !Character.isJavaIdentifierPart(chr)) {
return true;
}
}
return false;
}
}
return true;
}
/**
* Convert a base name to a legal Java class name. This implementation avoids using class names from the default
* import classes in java.lang, to avoid conflicts with the import handling in generated code.
*
* @param name base name
* @return converted name
*/
public String toJavaClassName(String name) {
// make sure initial letter is uppercase
int index = 0;
char chr;
while ((chr = name.charAt(index)) == '_') {
index++;
}
if (Character.isLowerCase(chr)) {
name = name.substring(0, index) + Character.toUpperCase(chr) + name.substring(index+1);
}
// prevent conflicts with default import classes
while (NameUtils.isDefaultImport(name)) {
name = "_" + name;
}
return name;
}
/**
* Convert an XML name to a Java value base name. The base name is in normalized camelcase form with leading lower
* case (unless the first word of the name is all uppercase).
*
* @param xname XML name
* @return converted name
*/
public String toBaseName(String xname) {
String name = trimXName(xname);
if (isConversionNeeded(name) || Character.isUpperCase(name.charAt(0))) {
// split trimmed name into a series of words
String[] words = splitXMLWords(name);
if (words.length == 0) {
return "x";
}
// use single underscore for empty result
if (words.length == 0) {
words = new String[] { "_" };
}
// form name by concatenating words with configured style
StringBuffer buff = new StringBuffer();
for (int i = 0; i < words.length; i++) {
String word = words[i];
if (i > 0 && m_underscore) {
buff.append('_');
}
if ((i == 0 && m_upperInitial) || (i > 0 && m_camelCase)) {
buff.append(Character.toUpperCase(word.charAt(0)));
if (word.length() > 1) {
buff.append(word.substring(1, word.length()));
}
} else {
buff.append(word);
}
}
name = buff.toString();
}
return name;
}
/**
* Convert text to constant name. The returned name is guaranteed not to match a Java keyword.
*
* @param text raw text to be converted
* @return constant name
*/
public String toConstantName(String text) {
// insert underscores to separate words of name, and convert invalid characters
StringBuffer buff = new StringBuffer(text.length());
boolean lastup = false;
boolean multup = false;
char lastchar = 0;
for (int index = 0; index < text.length(); index++) {
char chr = text.charAt(index);
if (index == 0 && !Character.isJavaIdentifierStart(chr)) {
buff.append('_');
}
if (Character.isJavaIdentifierPart(chr)) {
if (lastup) {
if (Character.isUpperCase(chr)) {
multup = true;
} else {
lastup = false;
if (chr == '_') {
multup = false;
} else if (multup) {
buff.insert(buff.length()-1, '_');
multup = false;
}
}
} else if (Character.isUpperCase(chr)) {
if (index > 0 && lastchar != '_') {
buff.append('_');
}
lastup = true;
multup = false;
}
lastchar = Character.toUpperCase(chr);
buff.append(lastchar);
}
}
if (buff.length() == 0) {
buff.append('_');
}
String name = buff.toString();
if (NameUtils.isReserved(name)) {
name = "_" + name;
}
return name;
}
/**
* Build a field name using supplied prefix and/or suffix.
*
* @param base normalized camelcase base name
* @param prefix text to be added at start of name
* @param suffix text to be added at end of name
* @return field name
*/
private String buildFieldName(String base, String prefix, String suffix) {
// check for any change needed
String name = base;
int added = prefix.length() + suffix.length();
boolean toupper = m_upperInitial && !Character.isUpperCase(name.charAt(0));
if (added == 0) {
// not adding prefix or suffix, check for case conversion
if (toupper) {
// convert first character to uppercase
StringBuffer buff = new StringBuffer(name);
buff.setCharAt(0, Character.toUpperCase(buff.charAt(0)));
name = buff.toString();
}
} else {
// append prefix and/or suffix, with case conversion if needed
StringBuffer buff = new StringBuffer(name.length() + added);
buff.append(prefix);
int offset = buff.length();
buff.append(name);
if (toupper) {
buff.setCharAt(offset, Character.toUpperCase(name.charAt(0)));
}
buff.append(suffix);
name = buff.toString();
}
// make sure the result doesn't match a reserved name
if (NameUtils.isReserved(name)) {
name = "_" + name;
}
return name;
}
/**
* Convert base name to normal field name. The returned name is guaranteed not to match a Java keyword.
*
* @param base normalized camelcase base name
* @return field name
*/
public String toFieldName(String base) {
String prefix = m_fieldPrefix;
String suffix = m_fieldSuffix;
return buildFieldName(base, prefix, suffix);
}
/**
* Convert base name to static field name. The returned name is guaranteed not to match a Java keyword.
*
* @param base normalized camelcase base name
* @return field name
*/
public String toStaticFieldName(String base) {
String prefix = m_staticPrefix;
String suffix = m_staticSuffix;
return buildFieldName(base, prefix, suffix);
}
/**
* Convert base name to property name (used for all method names). The property name is always in initial-upper
* camelcase form.
*
* @param base normalized camelcase base name
* @return property name in initial-upper camelcase form
*/
public String toPropertyName(String base) {
if (!Character.isUpperCase(base.charAt(0))) {
// convert first character to uppercase
StringBuffer buff = new StringBuffer(base);
buff.setCharAt(0, Character.toUpperCase(buff.charAt(0)));
return buff.toString();
} else {
// no change needed, just use base name directly
return base;
}
}
/**
* Convert property name to read access method name.
*
* @param prop property name in initial-upper camelcase form
* @return read access method name
*/
public String toReadAccessMethodName(String prop) {
return "get" + prop;
}
/**
* Convert property name to write access method name.
*
* @param prop property name in initial-upper camelcase form
* @return write access method name
*/
public String toWriteAccessMethodName(String prop) {
return "set" + prop;
}
/**
* Convert property name to write access method name.
*
* @param prop property name in initial-upper camelcase form
* @return write access method name
*/
public String toTestAccessMethodName(String prop) {
return "is" + prop;
}
/**
* Convert property name to if set access method name (for value in set of alternatives).
*
* @param prop property name in initial-upper camelcase form
* @return if set access method name
*/
public String toIfSetAccessMethodName(String prop) {
return "if" + prop;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/extend/NameMatchDecoratorBase.java 0000644 0001750 0001750 00000004617 11175604004 031146 0 ustar twerner twerner /*
* Copyright (c) 2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.extend;
import org.jibx.util.NameUtilities;
/**
* Base class for decorators which match on the generated class name.
*/
public abstract class NameMatchDecoratorBase implements ClassDecorator
{
/** Name pattern to be matched (null if none). */
private String m_matchName;
/**
* Set name pattern to be matched.
*
* @param match pattern to be matched (null if none, meaning match every name)
*/
public void setMatchName(String match) {
m_matchName = match;
}
/**
* Match class name against pattern.
*
* @param name
* @return true if name matches pattern, false if not
*/
protected boolean matchName(String name) {
if (m_matchName != null) {
return NameUtilities.isPatternMatch(name, m_matchName);
}
return true;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/extend/ListImplementationDecorator.java 0000644 0001750 0001750 00000006464 11175603452 032347 0 ustar twerner twerner /*
* Copyright (c) 2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.extend;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.jibx.binding.model.ElementBase;
import org.jibx.schema.codegen.IClassHolder;
/**
* Code generation decorator which changes the implementation class used for java.util.List instances.
*/
public class ListImplementationDecorator implements ClassDecorator
{
/** List implementation class to be used. */
private String m_listClass;
/**
* Set list class to be used.
*
* @param name
*/
public void setListClass(String name) {
m_listClass = name;
}
/**
* Method called after completing code generation for the target class. Unused for this decorator.
*
* @param binding
* @param holder
*/
public void finish(ElementBase binding, IClassHolder holder) {}
/**
* Method called before starting code generation for the target class. This just sets the list implementation class.
*
* @param holder
*/
public void start(IClassHolder holder) {
holder.setListImplementation(m_listClass);
}
/**
* Method called after adding each data value to class. Unused for this decorator.
*
* @param basename base name used for data value
* @param collect repeated value flag
* @param type value type (item value type, in the case of a repeated value)
* @param field actual field
* @param getmeth read access method
* @param setmeth write access method
* @param descript value description text
* @param holder
*/
public void valueAdded(String basename, boolean collect, String type, FieldDeclaration field,
MethodDeclaration getmeth, MethodDeclaration setmeth, String descript, IClassHolder holder) {}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/extend/NameConverter.java 0000644 0001750 0001750 00000012737 11365564364 027444 0 ustar twerner twerner /*
* Copyright (c) 2009-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.extend;
/**
* Interface for working with Java names during code generation.
*
* @author Dennis M. Sosnoski
*/
public interface NameConverter
{
/**
* Convert singular name to plural form.
*
* @param name base name
* @return plural name
*/
String pluralize(String name);
/**
* Convert potentially plural name to singular form.
*
* @param name base name
* @return singularized name
*/
String depluralize(String name);
/**
* Convert an XML name to a Java value base name. The base name is in normalized camelcase form with leading lower
* case (unless the first word of the name is all uppercase).
*
* @param xname XML name
* @return converted name
*/
String toBaseName(String xname);
/**
* Convert a base name to a legal Java class name.
*
* @param xname XML name
* @return converted name
*/
String toJavaClassName(String xname);
/**
* Convert text to constant name. The constant name must not match a Java keyword.
*
* @param text raw text to be converted
* @return constant name
*/
String toConstantName(String text);
/**
* Convert base name to normal field name. The field name must not match a Java keyword.
*
* @param base normalized camelcase base name
* @return field name
*/
String toFieldName(String base);
/**
* Convert base name to static field name. The field name must not match a Java keyword.
*
* @param base normalized camelcase base name
* @return field name
*/
String toStaticFieldName(String base);
/**
* Convert base name to property name (used for all method names). The property name is always in initial-upper
* camelcase form.
*
* @param base normalized camelcase base name
* @return property name in initial-upper camelcase form
*/
String toPropertyName(String base);
/**
* Convert property name to read access method name.
*
* @param prop property name in initial-upper camelcase form
* @return read access method name
*/
String toReadAccessMethodName(String prop);
/**
* Convert property name to write access method name.
*
* @param prop property name in initial-upper camelcase form
* @return write access method name
*/
String toWriteAccessMethodName(String prop);
/**
* Convert property name to test access method name (for boolean value).
*
* @param prop property name in initial-upper camelcase form
* @return test access method name
*/
String toTestAccessMethodName(String prop);
/**
* Convert property name to if set access method name (for value in set of alternatives).
*
* @param prop property name in initial-upper camelcase form
* @return if set access method name
*/
String toIfSetAccessMethodName(String prop);
/**
* Trim specified prefixes and/or suffixes from an XML name.
*
* @param xname XML name
* @return trimmed name, with specified prefixes and/or suffixes removed
*/
public String trimXName(String xname);
/**
* Split an XML name into words. This splits first on the basis of separator characters ('.', '-', and '_') in the
* name, and secondly based on case (an uppercase character immediately followed by one or more lowercase characters
* is considered a word, and multiple uppercase characters not followed immediately by a lowercase character are
* also considered a word). Characters which are not valid as parts of identifiers in Java are dropped from the XML
* name before it is split, and words starting with initial uppercase characters have the upper case dropped for
* consistency. Note that this method is not threadsafe.
*
* @param name
* @return array of words
*/
public String[] splitXMLWords(String name);
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/codegen/extend/CollectionMethodsDecorator.java 0000644 0001750 0001750 00000014747 11365041436 032147 0 ustar twerner twerner /*
* Copyright (c) 2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.codegen.extend;
import java.util.Iterator;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.jibx.binding.model.ElementBase;
import org.jibx.schema.codegen.IClassHolder;
import org.jibx.schema.codegen.NameUtils;
import org.jibx.util.NameUtilities;
/**
* Code generation decorator which adds sizeXXX(), addXXX(YYY) getXXX(int), and
* clearXXX() methods for each collection value using a java.util.List representation. In a
* change from the original version of this class, the form of the name used for the sizeXXX() and
* clearXXX() methods is based on the supplied getXXX() method, which normally uses a plural
* form of the name.
*/
public class CollectionMethodsDecorator implements ClassDecorator
{
/** Text for template class. */
private static final String s_classText = "class Gorph { java.util.List $1; " +
"/** Get the number of $0 items.\n * @return count\n */\npublic int size$5() { return $1.size(); }" +
"/** Add a $0 item.\n * @param item\n */\npublic void add$2($3 item) { $1.add(item); }" +
"/** Get $0 item by position.\n * @return item\n * @param index\n */\npublic $3 get$2(int index) { return $4$1.get(index); }" +
"/** Remove all $0 items.\n */\npublic void clear$5() { $1.clear(); } }";
// where $0 is the description text, $1 is the field name, $2 is the value name with initial uppercase character,
// $3 is the type, and $4 is a cast if an untyped list is used, or empty if a typed list is used
/** Parser instance used by class. */
private final ASTParser m_parser = ASTParser.newParser(AST.JLS3);
/**
* Method called after completing code generation for the target class.
*
* @param binding
* @param holder
*/
public void finish(ElementBase binding, IClassHolder holder) {}
/**
* Method called before starting code generation for the target class.
*
* @param holder
*/
public void start(IClassHolder holder) {}
/**
* Replace all occurrences of one string with another in a buffer.
*
* @param match
* @param replace
* @param buff
*/
private static void replace(String match, String replace, StringBuffer buff) {
int base = 0;
while ((base = buff.indexOf(match, base)) >= 0) {
buff.replace(base, base+match.length(), replace);
}
}
/**
* Method called after adding each data value to class.
*
* @param basename base name used for data value
* @param collect repeated value flag
* @param type value type (item value type, in the case of a repeated value)
* @param field actual field
* @param getmeth read access method (null if a flag value)
* @param setmeth write access method (null if a flag value)
* @param descript value description text
* @param holder
*/
public void valueAdded(String basename, boolean collect, String type, FieldDeclaration field,
MethodDeclaration getmeth, MethodDeclaration setmeth, String descript, IClassHolder holder) {
String fieldtype = field.getType().toString();
if (collect && (fieldtype.startsWith("List") || fieldtype.startsWith("java.util.List"))) {
// make substitutions in template text
StringBuffer buff = new StringBuffer(s_classText);
VariableDeclarationFragment vardecl = (VariableDeclarationFragment)field.fragments().get(0);
replace("$0", descript, buff);
replace("$1", vardecl.getName().getIdentifier(), buff);
replace("$2", NameUtilities.depluralize(NameUtils.toNameWord(basename)), buff);
replace("$3", holder.getTypeName(type), buff);
String cast = field.getType().isParameterizedType() ? "" : ("(" + type + ")");
replace("$4", cast, buff);
replace("$5", getmeth.getName().getIdentifier().substring(3), buff);
// parse the resulting text
m_parser.setSource(buff.toString().toCharArray());
CompilationUnit unit = (CompilationUnit)m_parser.createAST(null);
// add all methods from output tree to class under construction
TypeDeclaration typedecl = (TypeDeclaration)unit.types().get(0);
for (Iterator iter = typedecl.bodyDeclarations().iterator(); iter.hasNext();) {
ASTNode node = (ASTNode)iter.next();
if (node instanceof MethodDeclaration) {
holder.addMethod((MethodDeclaration)node);
}
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/IArity.java 0000644 0001750 0001750 00000005067 11126615502 023162 0 ustar twerner twerner /*
* Copyright (c) 2006-2008, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema;
import org.jibx.schema.types.Count;
/**
* Interface for schema components representing complex or simple values, which may be optional or repeating.
*/
public interface IArity
{
/**
* Get maximum number of times this item can occur.
*
* @return count
* @see org.jibx.schema.attributes.OccursAttributeGroup#getMaxOccurs()
*/
public Count getMaxOccurs();
/**
* Set maximum number of times this item can occur.
*
* @param count
* @see org.jibx.schema.attributes.OccursAttributeGroup#setMaxOccurs(Count)
*/
public void setMaxOccurs(Count count);
/**
* Get minimum number of times this item can occur.
*
* @return count
* @see org.jibx.schema.attributes.OccursAttributeGroup#getMinOccurs()
*/
public Count getMinOccurs();
/**
* Set minimum number of times this item can occur.
*
* @param count
* @see org.jibx.schema.attributes.OccursAttributeGroup#setMinOccurs(Count)
*/
public void setMinOccurs(Count count);
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/UsageFinder.java 0000644 0001750 0001750 00000036527 11062041260 024153 0 ustar twerner twerner /*
* Copyright (c) 2006-2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.apache.log4j.Logger;
import org.jibx.schema.ISchemaListener;
import org.jibx.schema.NameRegister;
import org.jibx.schema.SchemaContextTracker;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.SchemaVisitor;
import org.jibx.schema.TreeWalker;
import org.jibx.schema.elements.AnnotatedBase;
import org.jibx.schema.elements.AttributeElement;
import org.jibx.schema.elements.AttributeGroupRefElement;
import org.jibx.schema.elements.CommonTypeDefinition;
import org.jibx.schema.elements.ComplexExtensionElement;
import org.jibx.schema.elements.ComplexRestrictionElement;
import org.jibx.schema.elements.ElementElement;
import org.jibx.schema.elements.GroupRefElement;
import org.jibx.schema.elements.ListElement;
import org.jibx.schema.elements.OpenAttrBase;
import org.jibx.schema.elements.SchemaElement;
import org.jibx.schema.elements.SimpleExtensionElement;
import org.jibx.schema.elements.SimpleRestrictionElement;
import org.jibx.schema.elements.UnionElement;
import org.jibx.util.ReferenceCountMap;
/**
* Visitor to generate usage counts for schema components. This is somewhat messy, since there are so many different
* types of references in schema: 'ref' (attribute, attributeGroup, element, and group, to reference a global definition
* of same type), 'type' (attribute and element, reference a global type definition), 'base' (extension and
* restriction), 'itemType' (list), 'memberTypes' (union), 'substitutionGroup' (element), and 'refer' (unique).
* References can be recursively expanded by matching the reference set against the set of components processed, and
* processing any new references until the closure is obtained.
*
* @author Dennis M. Sosnoski
*/
public class UsageFinder
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(UsageFinder.class.getName());
/** Visitor used for finding references. */
private final UsageVisitor m_visitor;
/**
* Constructor.
*/
public UsageFinder() {
m_visitor = new UsageVisitor();
}
/**
* Get map of reference counts per component.
*
* @return count map
*/
public ReferenceCountMap getUsageMap() {
return m_visitor.getUsageMap();
}
/**
* Get the set of definitions referenced as optional or repeating.
*
* @return set
*/
public Set getNonSingletonSet() {
return m_visitor.getNonSingletonSet();
}
/**
* Add usage counts for a schema tree. This counts all references from the supplied schema, including references in
* other schemas referenced by the schema.
*
* @param schema
*/
public void countSchemaTree(SchemaElement schema) {
TreeWalker wlkr = new TreeWalker(null, m_visitor.getListener());
wlkr.walkSchema(schema, m_visitor);
}
/**
* Add usage counts for the reference closure of a definition.
*
* @param comp definition to be processed
*/
public void addReferenceClosure(AnnotatedBase comp) {
m_visitor.addReferenceClosure(comp);
}
/**
* Add usage counts for the reference closure of a supplied list of components.
*
* @param list starting schema components
*/
public void addReferenceClosure(List list) {
for (Iterator iter = list.iterator(); iter.hasNext();) {
addReferenceClosure((AnnotatedBase)iter.next());
}
}
/**
* Set the register to be used for resolving name references. This is not needed if counting references from a
* schema tree using {@link #countSchemaTree(SchemaElement)}, which always sets the register associated with the
* supplied schema.
*
* @param reg
*/
public void setNameRegister(NameRegister reg) {
m_visitor.setNameRegister(reg);
}
/**
* Clear the accumulated usage counts.
*/
public void reset() {
m_visitor.reset();
}
/**
* Visitor to accumulate usage of definitions.
*/
private static class UsageVisitor extends SchemaVisitor
{
/** Tracker for schema context information. */
private final SchemaContextTracker m_tracker;
/** Usage counts found for each global definition. */
private final ReferenceCountMap m_usageMap;
/** Set of definitions referenced as non-required or repeating items. */
private final Set m_nonSingletonSet;
/** Added references list (null if unused). */
private ArrayList m_newReferences;
/**
* Constructor.
*/
public UsageVisitor() {
m_tracker = new SchemaContextTracker();
m_usageMap = new ReferenceCountMap();
m_nonSingletonSet = new HashSet();
}
/**
* Get the schema change listener for this visitor.
*
* @return listener
*/
public ISchemaListener getListener() {
return m_tracker;
}
/**
* Convenience method for incrementing a use count. If tracking of added references is enabled this also adds
* the referenced object to the list if it's a first-time reference.
*
* @param obj referenced object (null if none, ignored if a schema type)
*/
private void countUse(Object obj) {
if (obj != null) {
AnnotatedBase comp = (AnnotatedBase)obj;
if (comp.getParent() != null) {
s_logger.debug(" incrementing usage count for " + SchemaUtils.describeComponent(comp));
if (m_usageMap.incrementCount(comp) == 1 && m_newReferences != null) {
if (comp.getParent() instanceof SchemaElement) {
s_logger.debug(" (first use for component, added to new references list)");
m_newReferences.add(obj);
} else if (((AnnotatedBase)obj).getParent() != null) {
throw new IllegalStateException("Internal error: non-global in usage counts");
}
}
}
}
}
/**
* Convenience method for recording a non-singleton reference.
*
* @param obj referenced object (null if none)
*/
private void addNonSingleton(Object obj) {
if (obj != null) {
if (m_nonSingletonSet.add(obj)) {
s_logger.debug(" flagged non-singleton use of " +
SchemaUtils.describeComponent((AnnotatedBase)obj));
}
}
}
/**
* Add usage counts for the reference closure of a definition. This counts all references from the definition,
* then all references from the definitions referenced by the original definition, and so on until no new
* references are found. This method may be called repeatedly, with the final results representing the closure
* of the union of the specified definitions (or the union of the closure, since these are the same).
*
* @param comp definition to be processed
*/
public void addReferenceClosure(AnnotatedBase comp) {
// create list for new references found during pass
if (m_newReferences == null) {
m_newReferences = new ArrayList();
}
// add all supplied components which have not already been processed
s_logger.debug("adding reference closure for " + SchemaUtils.describeComponent(comp));
int base = m_newReferences.size();
countUse(comp);
// loop processing new components until no more new components found
TreeWalker wlkr = new TreeWalker(null, m_tracker);
while (m_newReferences.size() > base) {
int limit = m_newReferences.size();
if (base > 0) {
s_logger.debug(" found " + (limit-base) + " new references in expansion pass");
}
for (int i = base; i < limit; i++) {
// make sure component is a user type (not schema type)
AnnotatedBase ref = (AnnotatedBase)m_newReferences.get(i);
OpenAttrBase parent = ref.getParent();
if (parent instanceof SchemaElement) {
// expand reference from this component
s_logger.debug(" adding reference closure for " + SchemaUtils.describeComponent(ref));
m_tracker.setNameRegister(((SchemaElement)parent).getRegister());
wlkr.walkElement(ref, this);
} else {
s_logger.debug(" reference closure with non-global definition " + ref);
}
}
base = limit;
}
}
/**
* Set the register to be used for resolving name references.
*
* @param reg
*/
public void setNameRegister(NameRegister reg) {
m_tracker.setNameRegister(reg);
}
/**
* Get map of reference counts per component.
*
* @return count map
*/
public ReferenceCountMap getUsageMap() {
return m_usageMap;
}
/**
* Get the set of definitions referenced as optional or repeating.
*
* @return set
*/
public Set getNonSingletonSet() {
return m_nonSingletonSet;
}
/**
* Clear all state information. This allows an instance to be reused.
*/
public void reset() {
m_usageMap.clear();
m_nonSingletonSet.clear();
m_newReferences = null;
}
//
// Exit methods for counting references
/*
* (non-Javadoc)
*
* @see org.jibx.schema.SchemaVisitor#exit(org.jibx.schema.elements.AttributeElement)
*/
public void exit(AttributeElement node) {
countUse(node.getReference());
if (node.getType() != null) {
countUse(node.getTypeDefinition());
}
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.SchemaVisitor#exit(org.jibx.schema.elements.AttributeGroupElement)
*/
public void exit(AttributeGroupRefElement node) {
countUse(node.getReference());
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.SchemaVisitor#exit(org.jibx.schema.elements.ComplexExtensionElement)
*/
public void exit(ComplexExtensionElement node) {
countUse(node.getBaseType());
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.SchemaVisitor#exit(org.jibx.schema.elements.ComplexRestrictionElement)
*/
public void exit(ComplexRestrictionElement node) {
countUse(node.getBaseType());
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.SchemaVisitor#exit(org.jibx.schema.elements.ElementElement)
*/
public void exit(ElementElement node) {
if (node.getRef() != null) {
// record element reference
countUse(node.getReference());
if (!SchemaUtils.isSingletonElement(node)) {
addNonSingleton(node.getReference());
}
} else if (node.getType() != null) {
// record type reference
countUse(node.getTypeDefinition());
if (!SchemaUtils.isSingletonElement(node)) {
addNonSingleton(node.getTypeDefinition());
}
}
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.SchemaVisitor#exit(org.jibx.schema.elements.GroupElement)
*/
public void exit(GroupRefElement node) {
countUse(node.getReference());
if (!SchemaUtils.isSingleton(node)) {
addNonSingleton(node);
}
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.SchemaVisitor#exit(org.jibx.schema.elements.ListElement)
*/
public void exit(ListElement node) {
countUse(node.getItemTypeDefinition());
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.SchemaVisitor#exit(org.jibx.schema.elements.SimpleExtensionElement)
*/
public void exit(SimpleExtensionElement node) {
countUse(node.getBaseType());
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.SchemaVisitor#exit(org.jibx.schema.elements.SimpleRestrictionElement)
*/
public void exit(SimpleRestrictionElement node) {
if (node.getBase() != null) {
countUse(node.getBaseType());
}
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.SchemaVisitor#exit(org.jibx.schema.elements.UnionElement)
*/
public void exit(UnionElement node) {
CommonTypeDefinition[] types = node.getMemberTypeDefinitions();
if (types != null) {
for (int i = 0; i < types.length; i++) {
countUse(types[i]);
}
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/SchemaVisitorDelegate.java 0000644 0001750 0001750 00000024765 10651201410 026171 0 ustar twerner twerner /*
* Copyright (c) 2007, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema;
import org.jibx.schema.elements.AllElement;
import org.jibx.schema.elements.AnnotatedBase;
import org.jibx.schema.elements.AnnotationElement;
import org.jibx.schema.elements.AnnotationItem;
import org.jibx.schema.elements.AnyAttributeElement;
import org.jibx.schema.elements.AnyElement;
import org.jibx.schema.elements.AppInfoElement;
import org.jibx.schema.elements.AttributeElement;
import org.jibx.schema.elements.AttributeGroupElement;
import org.jibx.schema.elements.AttributeGroupRefElement;
import org.jibx.schema.elements.ChoiceElement;
import org.jibx.schema.elements.CommonComplexModification;
import org.jibx.schema.elements.CommonCompositorDefinition;
import org.jibx.schema.elements.CommonTypeDefinition;
import org.jibx.schema.elements.ComplexContentElement;
import org.jibx.schema.elements.ComplexExtensionElement;
import org.jibx.schema.elements.ComplexRestrictionElement;
import org.jibx.schema.elements.ComplexTypeElement;
import org.jibx.schema.elements.DocumentationElement;
import org.jibx.schema.elements.SchemaBase;
import org.jibx.schema.elements.ElementElement;
import org.jibx.schema.elements.GroupElement;
import org.jibx.schema.elements.GroupRefElement;
import org.jibx.schema.elements.ImportElement;
import org.jibx.schema.elements.IncludeElement;
import org.jibx.schema.elements.ListElement;
import org.jibx.schema.elements.OpenAttrBase;
import org.jibx.schema.elements.RedefineElement;
import org.jibx.schema.elements.SchemaElement;
import org.jibx.schema.elements.SchemaLocationBase;
import org.jibx.schema.elements.SequenceElement;
import org.jibx.schema.elements.SimpleContentElement;
import org.jibx.schema.elements.SimpleExtensionElement;
import org.jibx.schema.elements.SimpleRestrictionElement;
import org.jibx.schema.elements.SimpleTypeElement;
import org.jibx.schema.elements.UnionElement;
/**
* Instance of {@link SchemaVisitor} that delegates to another instance. This is provided as a base class, allowing
* selective overrides of normal visitor handling.
*
* @author Dennis M. Sosnoski
*/
public class SchemaVisitorDelegate extends SchemaVisitor
{
/** Delegate visitor. */
private final SchemaVisitor m_delegate;
/**
* Constructor.
*
* @param delegate
*/
public SchemaVisitorDelegate(final SchemaVisitor delegate) {
super();
m_delegate = delegate;
}
public void exit(AllElement node) {
m_delegate.exit(node);
}
public void exit(AnnotatedBase node) {
m_delegate.exit(node);
}
public void exit(AnnotationElement node) {
m_delegate.exit(node);
}
public void exit(AnnotationItem node) {
m_delegate.exit(node);
}
public void exit(AnyAttributeElement node) {
m_delegate.exit(node);
}
public void exit(AnyElement node) {
m_delegate.exit(node);
}
public void exit(AppInfoElement node) {
m_delegate.exit(node);
}
public void exit(AttributeElement node) {
m_delegate.exit(node);
}
public void exit(AttributeGroupElement node) {
m_delegate.exit(node);
}
public void exit(AttributeGroupRefElement node) {
m_delegate.exit(node);
}
public void exit(ChoiceElement node) {
m_delegate.exit(node);
}
public void exit(CommonComplexModification node) {
m_delegate.exit(node);
}
public void exit(CommonCompositorDefinition node) {
m_delegate.exit(node);
}
public void exit(CommonTypeDefinition node) {
m_delegate.exit(node);
}
public void exit(ComplexContentElement node) {
m_delegate.exit(node);
}
public void exit(ComplexExtensionElement node) {
m_delegate.exit(node);
}
public void exit(ComplexRestrictionElement node) {
m_delegate.exit(node);
}
public void exit(ComplexTypeElement node) {
m_delegate.exit(node);
}
public void exit(DocumentationElement node) {
m_delegate.exit(node);
}
public void exit(SchemaBase node) {
m_delegate.exit(node);
}
public void exit(ElementElement node) {
m_delegate.exit(node);
}
public void exit(GroupElement node) {
m_delegate.exit(node);
}
public void exit(GroupRefElement node) {
m_delegate.exit(node);
}
public void exit(ImportElement node) {
m_delegate.exit(node);
}
public void exit(IncludeElement node) {
m_delegate.exit(node);
}
public void exit(ListElement node) {
m_delegate.exit(node);
}
public void exit(OpenAttrBase node) {
m_delegate.exit(node);
}
public void exit(RedefineElement node) {
m_delegate.exit(node);
}
public void exit(SchemaElement node) {
m_delegate.exit(node);
}
public void exit(SchemaLocationBase node) {
m_delegate.exit(node);
}
public void exit(SequenceElement node) {
m_delegate.exit(node);
}
public void exit(SimpleContentElement node) {
m_delegate.exit(node);
}
public void exit(SimpleExtensionElement node) {
m_delegate.exit(node);
}
public void exit(SimpleRestrictionElement node) {
m_delegate.exit(node);
}
public void exit(SimpleTypeElement node) {
m_delegate.exit(node);
}
public void exit(UnionElement node) {
m_delegate.exit(node);
}
public boolean visit(AllElement node) {
return m_delegate.visit(node);
}
public boolean visit(AnnotatedBase node) {
return m_delegate.visit(node);
}
public boolean visit(AnnotationElement node) {
return m_delegate.visit(node);
}
public boolean visit(AnnotationItem node) {
return m_delegate.visit(node);
}
public boolean visit(AnyAttributeElement node) {
return m_delegate.visit(node);
}
public boolean visit(AnyElement node) {
return m_delegate.visit(node);
}
public boolean visit(AppInfoElement node) {
return m_delegate.visit(node);
}
public boolean visit(AttributeElement node) {
return m_delegate.visit(node);
}
public boolean visit(AttributeGroupElement node) {
return m_delegate.visit(node);
}
public boolean visit(AttributeGroupRefElement node) {
return m_delegate.visit(node);
}
public boolean visit(ChoiceElement node) {
return m_delegate.visit(node);
}
public boolean visit(CommonComplexModification node) {
return m_delegate.visit(node);
}
public boolean visit(CommonCompositorDefinition node) {
return m_delegate.visit(node);
}
public boolean visit(CommonTypeDefinition node) {
return m_delegate.visit(node);
}
public boolean visit(ComplexContentElement node) {
return m_delegate.visit(node);
}
public boolean visit(ComplexExtensionElement node) {
return m_delegate.visit(node);
}
public boolean visit(ComplexRestrictionElement node) {
return m_delegate.visit(node);
}
public boolean visit(ComplexTypeElement node) {
return m_delegate.visit(node);
}
public boolean visit(DocumentationElement node) {
return m_delegate.visit(node);
}
public boolean visit(SchemaBase node) {
return m_delegate.visit(node);
}
public boolean visit(ElementElement node) {
return m_delegate.visit(node);
}
public boolean visit(GroupElement node) {
return m_delegate.visit(node);
}
public boolean visit(GroupRefElement node) {
return m_delegate.visit(node);
}
public boolean visit(ImportElement node) {
return m_delegate.visit(node);
}
public boolean visit(IncludeElement node) {
return m_delegate.visit(node);
}
public boolean visit(ListElement node) {
return m_delegate.visit(node);
}
public boolean visit(OpenAttrBase node) {
return m_delegate.visit(node);
}
public boolean visit(RedefineElement node) {
return m_delegate.visit(node);
}
public boolean visit(SchemaElement node) {
return m_delegate.visit(node);
}
public boolean visit(SchemaLocationBase node) {
return m_delegate.visit(node);
}
public boolean visit(SequenceElement node) {
return m_delegate.visit(node);
}
public boolean visit(SimpleContentElement node) {
return m_delegate.visit(node);
}
public boolean visit(SimpleExtensionElement node) {
return m_delegate.visit(node);
}
public boolean visit(SimpleRestrictionElement node) {
return m_delegate.visit(node);
}
public boolean visit(SimpleTypeElement node) {
return m_delegate.visit(node);
}
public boolean visit(UnionElement node) {
return m_delegate.visit(node);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/UrlResolver.java 0000644 0001750 0001750 00000010263 11336101042 024227 0 ustar twerner twerner /*
* Copyright (c) 2007-2010, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
/**
* Basic resolver supporting relative URL paths.
*
* @author Dennis M. Sosnoski
*/
public class UrlResolver implements ISchemaResolver
{
/** Schema document URL. */
private final URL m_url;
/** Schema name. */
private final String m_name;
/** Unique identifier for this schema document. */
private final String m_id;
/**
* Constructor. This converts paths to a standard form by eliminating "./" and "../" relative path components.
*
* @param path
* @param url
*/
public UrlResolver(String path, URL url) {
m_url = url;
String file = url.getFile();
int offset;
int base = 0;
while ((offset = file.indexOf("/./", base)) >= 0) {
file = file.substring(0, offset) + file.substring(offset+2);
base = offset;
}
base = 1;
while (file.length() > 1 && (offset = file.indexOf("/../", base)) >= 0) {
int prior = file.lastIndexOf('/', offset-1);
if (prior > 0) {
file = file.substring(0, prior) + file.substring(offset+3);
base = prior;
} else {
base = offset + 3;
}
}
m_id = url.getProtocol().toLowerCase() + "://" + url.getHost().toLowerCase() + file;
path.replace('\\', '/');
int start = path.lastIndexOf('/');
m_name = path.substring(start+1);
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ISchemaResolver#getContent()
*/
public InputStream getContent() throws IOException {
return m_url.openStream();
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ISchemaResolver#getName()
*/
public String getName() {
return m_name;
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ISchemaResolver#getId()
*/
public String getId() {
return m_id;
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ISchemaResolver#resolve(java.lang.String,java.lang.String)
*/
public ISchemaResolver resolve(String loc, String tns) throws IOException {
return new UrlResolver(loc, new URL(m_url, loc));
}
/**
* Get the document URL.
*
* @return url
*/
public URL getUrl() {
return m_url;
}
public boolean equals(Object obj) {
if (obj instanceof UrlResolver) {
return m_id.equals(((UrlResolver)obj).m_id);
} else {
return false;
}
}
public int hashCode() {
return m_id.hashCode();
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/ 0000755 0001750 0001750 00000000000 11526304016 022721 5 ustar twerner twerner libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/AttributeGroupRefElement.java 0000644 0001750 0001750 00000010630 11167465000 030515 0 ustar twerner twerner /*
Copyright (c) 2006-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.schema.IReference;
import org.jibx.schema.support.QNameConverter;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Definition for embedded attributeGroup element (attribute group
* reference).
*
* @author Dennis M. Sosnoski
*/
public class AttributeGroupRefElement extends AnnotatedBase implements IReference
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "ref" },
AnnotatedBase.s_allowedAttributes);
//
// Instance data
/** Reference definition. */
private QName m_ref;
/** Referenced element (filled in by validation). */
private AttributeGroupElement m_refGroup;
/**
* Constructor.
*/
public AttributeGroupRefElement() {
super(ATTRIBUTEGROUP_TYPE);
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Access methods
/**
* Get 'ref' attribute value.
*
* @return ref
*/
public QName getRef() {
return m_ref;
}
/**
* Set 'ref' attribute value.
*
* @param ref
*/
public void setRef(QName ref) {
m_ref = ref;
}
/**
* Get the referenced attributeGroup declaration. This method is only usable
* after validation.
*
* @return referenced group definition
*/
public AttributeGroupElement getReference() {
return m_refGroup;
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
if (m_ref == null) {
vctx.addFatal("'ref' attribute is required for attributeGroup reference", this);
} else {
SchemaElement schema = vctx.getCurrentSchema();
String ens = schema.getEffectiveNamespace();
QNameConverter.patchQNameNamespace(ens, m_ref);
}
}
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#validate(org.jibx.schema.ValidationContext)
*/
public void validate(ValidationContext vctx) {
// make sure element reference is defined
m_refGroup = vctx.findAttributeGroup(m_ref);
if (m_refGroup == null) {
vctx.addFatal("Referenced attributeGroup '" + m_ref + "' is not defined", this);
}
// handle base class validation
super.validate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/AllElement.java 0000644 0001750 0001750 00000006360 10624256126 025621 0 ustar twerner twerner /*
Copyright (c) 2006-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.schema.types.Count;
import org.jibx.schema.validation.ValidationContext;
/**
* <all> element definition. Even though <all> is considered a compositor
* by the schema specification, it has substantial restrictions on use.
*
* @author Dennis M. Sosnoski
*/
public class AllElement extends CommonCompositorDefinition
{
/** Mask bits for allowed child elements. */
private static long PARTICLE_MASK = ELEMENT_MASKS[ELEMENT_TYPE];
/**
* Constructor.
*/
public AllElement() {
super(ALL_TYPE, PARTICLE_MASK);
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.AnnotatedBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// handle base class prevalidation first so values will be available
super.prevalidate(vctx);
// check added constraints for all
Count count = getMaxOccurs();
if (count != null && (count.isUnbounded() || count.getCount() != 1)) {
vctx.addError("The element only allows 'maxOccurs' of '1'", this);
}
count =getMinOccurs();
if (count != null && (count.isUnbounded() || count.getCount() > 1)) {
vctx.addError("The element only allows 'minOccurs' of '0' or '1'", this);
}
}
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#validate(org.jibx.schema.ValidationContext)
*/
public void validate(ValidationContext vctx) {
// TODO handle checks to make sure each element child has minOccurs=0 or 1
// and maxOccurs=1
// continue with base class prevalidation
super.validate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/KeyBase.java 0000644 0001750 0001750 00000016701 11167465000 025116 0 ustar twerner twerner /*
* Copyright (c) 2008-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.schema.support.QNameConverter;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Base representation for identity constraint elements. The actual identity constraint elements are represented as
* static inner classes.
*
* @author Dennis M. Sosnoski
*/
public class KeyBase extends AnnotatedBase
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes = new StringArray(new String[] { "name" },
AnnotatedBase.s_allowedAttributes);
//
// Instance data
/** Filtered list of selector element (one only). */
private final FilteredSegmentList m_selectorList;
/** Filtered list of field elements (one or more). */
private final FilteredSegmentList m_fieldList;
/** 'name' attribute value. */
private String m_name;
/**
* Constructor.
*
* @param type
*/
public KeyBase(int type) {
super(type);
m_selectorList = new FilteredSegmentList(getChildrenWritable(), ELEMENT_MASKS[SELECTOR_TYPE], this);
m_fieldList = new FilteredSegmentList(getChildrenWritable(), ELEMENT_MASKS[FIELD_TYPE], m_selectorList, this);
}
//
// Base class overrides
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Access methods
/**
* Get 'name' attribute value.
*
* @return name
*/
public String getName() {
return m_name;
}
/**
* Set 'name' attribute value.
*
* @param name
*/
public void setName(String name) {
m_name = name;
}
/**
* Get selector child element.
*
* @return element, or null if none
*/
public SelectionBase.SelectorElement getSelector() {
return m_selectorList.size() > 0 ? (SelectionBase.SelectorElement)m_selectorList.get(0) : null;
}
/**
* Set selector child element.
*
* @param element element, or null if unsetting
*/
public void setSelector(SelectionBase.SelectorElement element) {
m_selectorList.clear();
if (element != null) {
m_selectorList.add(element);
}
}
/**
* Get list of field child elements.
*
* @return list
*/
public FilteredSegmentList getFieldList() {
return m_fieldList;
}
//
// Validation methods
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
if (getName() == null) {
vctx.addError("The 'name' attribute is required for identity constraint elements", this);
}
super.prevalidate(vctx);
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ComponentBase#validate(org.jibx.schema.ValidationContext)
*/
public void validate(ValidationContext vctx) {
// make sure the expected child elements are present
if (m_selectorList.size() != 1) {
vctx.addError("One and only one 'selector' child element is required", this);
}
if (m_fieldList.size() == 0) {
vctx.addError("At least one 'field' child element is required", this);
}
// handle base class validation if still going
if (!vctx.isSkipped(this)) {
super.validate(vctx);
}
}
//
// Actual element subclasses
public static class KeyElement extends KeyBase
{
/**
* Constructor. Just sets element type in base class.
*/
public KeyElement() {
super(KEY_TYPE);
}
}
public static class KeyrefElement extends KeyBase
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes = new StringArray(new String[] { "refer" },
KeyBase.s_allowedAttributes);
//
// Instance data
/** 'refer' attribute value. */
private QName m_refer;
/**
* Constructor. Just sets element type in base class.
*/
public KeyrefElement() {
super(KEYREF_TYPE);
}
/**
* Get 'refer' attribute value.
*
* @return refer
*/
public QName getRefer() {
return m_refer;
}
/**
* Set 'refer' attribute value.
*
* @param refer
*/
public void setName(QName refer) {
m_refer = refer;
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
if (m_refer == null) {
vctx.addFatal("'refer' attribute is required by keyref element", this);
} else {
// patch qualified names with schema effective namespace
SchemaElement schema = vctx.getCurrentSchema();
String ens = schema.getEffectiveNamespace();
QNameConverter.patchQNameNamespace(ens, m_refer);
}
}
}
public static class UniqueElement extends KeyBase
{
/**
* Constructor. Just sets element type in base class.
*/
public UniqueElement() {
super(UNIQUE_TYPE);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/CommonComplexModification.java 0000644 0001750 0001750 00000013453 11356635364 030716 0 ustar twerner twerner /*
* Copyright (c) 2006-2010, Dennis M. Sosnoski. 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. Neither the name of JiBX nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.validation.ValidationContext;
/**
* Base representation for all complex type modification elements. This includes
* both extension and restriction, but only when used with
* complex types.
*
* @author Dennis M. Sosnoski
*/
public abstract class CommonComplexModification extends CommonTypeDerivation
implements IComplexStructure
{
/** Mask bits for content definition child elements. */
private long CONTENT_DEFINITION_MASK = ELEMENT_MASKS[ALL_TYPE]
| ELEMENT_MASKS[CHOICE_TYPE] | ELEMENT_MASKS[GROUP_TYPE]
| ELEMENT_MASKS[SEQUENCE_TYPE];
/** Mask bits for attribute child elements. */
private long ATTRIBUTE_MASK = ELEMENT_MASKS[ATTRIBUTE_TYPE]
| ELEMENT_MASKS[ATTRIBUTEGROUP_TYPE];
/** Mask bits for attribute child elements. */
private long ANYATTRIBUTE_MASK = ELEMENT_MASKS[ANYATTRIBUTE_TYPE];
//
// Instance data
/** Filtered list of content definitions. */
private final FilteredSegmentList m_contentDefinitionList;
/** Filtered list of attribute definitions. */
private final FilteredSegmentList m_attributeList;
/** Filtered list of anyAttribute definitions (zero or one). */
private final FilteredSegmentList m_anyAttributeList;
/**
* Constructor.
*
* @param type actual element type
*/
public CommonComplexModification(int type) {
super(type);
m_contentDefinitionList = new FilteredSegmentList(
getChildrenWritable(), CONTENT_DEFINITION_MASK, this);
m_attributeList = new FilteredSegmentList(getChildrenWritable(),
ATTRIBUTE_MASK, m_contentDefinitionList, this);
m_anyAttributeList = new FilteredSegmentList(getChildrenWritable(),
ANYATTRIBUTE_MASK, m_attributeList, this);
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.elements.CommonTypeDerivation#isComplexType()
*/
public boolean isComplexType() {
return true;
}
/* (non-Javadoc)
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
/* (non-Javadoc)
* @see org.jibx.schema.elements.IComplexStructure#getContentDefinition()
*/
public CommonCompositorBase getContentDefinition() {
return m_contentDefinitionList.size() > 0 ?
(CommonCompositorBase)m_contentDefinitionList.get(0) : null;
}
/* (non-Javadoc)
* @see org.jibx.schema.elements.IComplexStructure#setContentDefinition(org.jibx.schema.elements.CommonCompositorDefinition)
*/
public void setContentDefinition(CommonCompositorBase element) {
m_contentDefinitionList.clear();
if (element != null) {
m_contentDefinitionList.add(element);
}
}
/* (non-Javadoc)
* @see org.jibx.schema.elements.IComplexStructure#getAttributeList()
*/
public FilteredSegmentList getAttributeList() {
return m_attributeList;
}
/* (non-Javadoc)
* @see org.jibx.schema.elements.IComplexStructure#getAnyAttribute()
*/
public AnyAttributeElement getAnyAttribute() {
return m_anyAttributeList.size() > 0
? (AnyAttributeElement)m_anyAttributeList.get(0) : null;
}
/* (non-Javadoc)
* @see org.jibx.schema.elements.IComplexStructure#setAnyAttribute(org.jibx.schema.elements.AnyAttributeElement)
*/
public void setAnyAttribute(AnyAttributeElement element) {
m_anyAttributeList.clear();
if (element != null) {
m_anyAttributeList.add(element);
}
}
//
// Validation methods
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check form of definition
if (m_anyAttributeList.size() > 1) {
vctx.addError("Only one child allowed", this);
}
// continue with parent class prevalidation
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/AnnotatedBase.java 0000644 0001750 0001750 00000007333 11062041204 026272 0 ustar twerner twerner /*
Copyright (c) 2006-2008, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.schema.support.Conversions;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Base class for all element structures in schema definition which support
* annotations. The 'id' attribute handling is also implemented in this class,
* since it goes together with the annotation support in the schema for schema.
* Finally, this class maintains the parent element relationship.
*
* @author Dennis M. Sosnoski
*/
public abstract class AnnotatedBase extends OpenAttrBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "id" });
//
// Instance data
/** Annotation for this element (null if none). */
private AnnotationElement m_annotation;
/** "id" attribute value. */
private String m_id;
/**
* Constructor.
*
* @param type element type
*/
protected AnnotatedBase(int type) {
super(type);
}
/**
* Get annotation.
*
* @return annotation element (null if none)
*/
public final AnnotationElement getAnnotation() {
return m_annotation;
}
/**
* Set annotation.
*
* @param ann annotation element (null if none)
*/
public final void setAnnotation(AnnotationElement ann) {
m_annotation = ann;
if (ann != null) {
ann.setParent(this);
}
}
/**
* Get "id" attribute value.
*
* @return id attribute value
*/
public String getId() {
return m_id;
}
/**
* Set "id" value for element.
*
* @param id id attribute value
*/
public void setId(String id) {
m_id = id;
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check for valid "id" attribute value
m_id = Conversions.deserializeNCName(m_id, vctx, this);
// continue with parent class prevalidation
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/CommonCompositorBase.java 0000644 0001750 0001750 00000007617 11062041160 027672 0 ustar twerner twerner /*
Copyright (c) 2006-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.schema.IArity;
import org.jibx.schema.attributes.OccursAttributeGroup;
import org.jibx.schema.types.Count;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Base class for all complex content model compositors. This includes the
* special case of the <group> (reference) compositor, which doesn't contain
* any children but acts as a placeholder for the compositor in the <group>
* definition.
*
* @author Dennis M. Sosnoski
*/
public abstract class CommonCompositorBase extends AnnotatedBase implements IArity
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes =
new StringArray(OccursAttributeGroup.s_allowedAttributes,
AnnotatedBase.s_allowedAttributes);
//
// Instance data
/** Attribute values for specify occurance constraints. */
private OccursAttributeGroup m_occurs;
/**
* Constructor.
*
* @param type element type
*/
protected CommonCompositorBase(int type) {
super(type);
m_occurs = new OccursAttributeGroup(this);
}
//
// Access methods
//
// Attribute delegate methods
/* (non-Javadoc)
* @see org.jibx.schema.attributes.OccursAttributeGroup#getMaxOccurs()
*/
public Count getMaxOccurs() {
return m_occurs.getMaxOccurs();
}
/* (non-Javadoc)
* @see org.jibx.schema.attributes.OccursAttributeGroup#getMinOccurs()
*/
public Count getMinOccurs() {
return m_occurs.getMinOccurs();
}
/* (non-Javadoc)
* @see org.jibx.schema.attributes.OccursAttributeGroup#setMaxOccurs(org.jibx.schema.attributes.Count)
*/
public void setMaxOccurs(Count count) {
m_occurs.setMaxOccurs(count);
}
/* (non-Javadoc)
* @see org.jibx.schema.attributes.OccursAttributeGroup#setMinOccurs(org.jibx.schema.attributes.Count)
*/
public void setMinOccurs(Count count) {
m_occurs.setMinOccurs(count);
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.AnnotatedBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// validate the attributes
m_occurs.prevalidate(vctx);
// continue with base class prevalidation
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/ListElement.java 0000644 0001750 0001750 00000014046 11167465000 026020 0 ustar twerner twerner /*
* Copyright (c) 2006-2009, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.schema.support.QNameConverter;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* list element definition.
*
* @author Dennis M. Sosnoski
*/
public class ListElement extends AnnotatedBase
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "itemType" }, AnnotatedBase.s_allowedAttributes);
/** Mask bits for inline base type definition. */
private long INLINE_TYPE_MASK = ELEMENT_MASKS[SIMPLETYPE_TYPE];
//
// Instance data
/** Filtered list of inline base type definition element. */
private final FilteredSegmentList m_inlineBaseList;
/** 'itemType' attribute value. */
private QName m_itemType;
/** Actual definition corresponding to 'itemType' attribute value (set during validation). */
private CommonTypeDefinition m_itemTypeDefinition;
/**
* Constructor.
*/
public ListElement() {
super(LIST_TYPE);
m_inlineBaseList = new FilteredSegmentList(getChildrenWritable(), INLINE_TYPE_MASK, this);
}
//
// Base class overrides
/*
* (non-Javadoc)
*
* @see org.jibx.binding.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Accessor methods
/**
* Get 'itemType' attribute value.
*
* @return attribute value, or null if none
*/
public QName getItemType() {
return m_itemType;
}
/**
* Set 'itemType' attribute value.
*
* @param base attribute value, or null if none
*/
public void setItemType(QName base) {
m_itemType = base;
}
/**
* Get referenced item type definition. This method can only be called after validation.
*
* @return item type, or null if none
*/
public CommonTypeDefinition getItemTypeDefinition() {
return m_itemTypeDefinition;
}
/**
* Get inline base type definition element.
*
* @return inline base type, or null if none
*/
public SimpleTypeElement getDerivation() {
return m_inlineBaseList.size() > 0 ? (SimpleTypeElement)m_inlineBaseList.get(0) : null;
}
/**
* Set inline base type definition element.
*
* @param element inline base type, or null if unsetting
*/
public void setDerivation(SimpleTypeElement element) {
m_inlineBaseList.clear();
if (element != null) {
m_inlineBaseList.add(element);
}
}
//
// Validation methods
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check for missing or conflicting type information
if (m_inlineBaseList.size() == 0 && m_itemType == null) {
vctx.addError("Must have 'itemType' attribute or inline definition", this);
}
if (m_inlineBaseList.size() > 0 && m_itemType != null) {
vctx.addError("Can only use 'itemType' attribute without inline definition", this);
}
if (m_inlineBaseList.size() > 1) {
vctx.addError("Only one inline definition allowed", this);
}
// patch qualified name with schema effective namespace
SchemaElement schema = vctx.getCurrentSchema();
String ens = schema.getEffectiveNamespace();
QNameConverter.patchQNameNamespace(ens, m_itemType);
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ComponentBase#validate(org.jibx.schema.ValidationContext)
*/
public void validate(ValidationContext vctx) {
// look up referenced type definition
if (m_itemType != null) {
m_itemTypeDefinition = vctx.findType(m_itemType);
if (m_itemTypeDefinition == null) {
vctx.addFatal("Referenced type '" + m_itemType + "' is not defined", this);
}
}
// continue with parent class validation
super.validate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/SchemaPath.java 0000644 0001750 0001750 00000043755 11145001172 025611 0 ustar twerner twerner /*
* Copyright (c) 2007-2009, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.elements;
import java.util.ArrayList;
import java.util.List;
import org.jibx.runtime.QName;
import org.jibx.schema.INamed;
import org.jibx.schema.IReference;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.LazyList;
/**
* Path specification within a schema definition. This implements simple XPath-like expressions, consisting of any
* number of path components given as element names or '*' for any element or '**' for any nesting of elements, along
* with optional position number or name attribute predicates in square brackets.
*
* @author Dennis M. Sosnoski
*/
public class SchemaPath
{
/** Single element wildcard step. */
private static final StepBase WILDCARD_ELEMENT_STEP = new StepBase() {
public boolean isRepeating() {
return false;
}
public boolean match(OpenAttrBase elem) {
return true;
}
public int position() {
return -1;
}
};
/** Nesteing element wildcard step. */
private static final StepBase WILDCARD_NESTING_STEP = new StepBase() {
public boolean isRepeating() {
return true;
}
public boolean match(OpenAttrBase elem) {
return true;
}
public int position() {
return -1;
}
};
/** Source object for path expression. */
private final Object m_sourceObject;
/** Validation context used for reporting errors. */
private final ValidationContext m_validationContext;
/** Path steps. */
private StepBase[] m_steps;
/**
* Constructor.
*
* @param obj source object for expression
* @param vctx validation context
*/
private SchemaPath(Object obj, ValidationContext vctx) {
m_sourceObject = obj;
m_validationContext = vctx;
}
/**
* Validate a name attribute value.
*
* @param nameattr name value
* @return true if valid, false if not
*/
private boolean validateName(String nameattr) {
for (int i = 0; i < nameattr.length(); i++) {
char chr = nameattr.charAt(i);
if (!Character.isLetter(chr) && chr != '.' && chr != '_' && chr != '-' &&
(i <= 0 || !Character.isDigit(chr))) {
m_validationContext.addError("Invalid path expression name predicate '" + nameattr + '\'',
m_sourceObject);
return false;
}
}
return true;
}
/**
* Validate and convert a position value.
*
* @param postext position text
* @return position value (strictly positive), or -1 if error
*/
private int convertPosition(String postext) {
// first check that all characters are digits (for better error message)
for (int i = 0; i < postext.length(); i++) {
char chr = postext.charAt(i);
if (chr < '0' || chr > '9') {
if (i == 0) {
m_validationContext.addError("Unknown path expression predicate '" + postext + '\'',
m_sourceObject);
} else {
m_validationContext.addError("Illegal character in path expression position predicate '" + postext +
"' (must be digits only)", m_sourceObject);
}
return -1;
}
}
// convert the actual position value
int position = -1;
try {
position = Integer.parseInt(postext);
if (position <= 0) {
m_validationContext.addError("Path expression position predicate value must be >= 1", m_sourceObject);
}
} catch (NumberFormatException e) {
m_validationContext.addError("Error parsing position predicate in path expression", m_sourceObject);
}
return position;
}
/**
* Build a path step.
*
* @param step expression
* @return constructed step, or null if error
*/
private StepBase buildPathStep(String step) {
if ("*".equals(step)) {
return WILDCARD_ELEMENT_STEP;
} else if ("**".equals(step)) {
return WILDCARD_NESTING_STEP;
} else {
// check if there's a predicate present
boolean valid = true;
String elemname = null;
String nameattr = null;
String postext = null;
int split = step.indexOf('[');
if (split >= 0) {
// split off element name as part before predicate start
elemname = step.substring(0, split);
step = step.substring(split + 1);
// make sure there's a matching predicate end
split = step.indexOf(']');
if (split >= 0) {
// check type of predicate
String clause = step.substring(0, split).trim();
if (clause.startsWith("@name=")) {
nameattr = clause.substring(6);
valid = validateName(nameattr);
} else {
postext = clause;
}
// check for a second predicate
step = step.substring(split + 1);
if (step.length() > 0) {
// second predicate must be position
int end = step.length() - 1;
if (step.charAt(0) == '[' && step.charAt(end) == ']') {
clause = step.substring(1, end).trim();
if (postext == null) {
postext = clause;
} else {
m_validationContext.addError("Multiple predicates only allowed in path expression " +
"with [@name=xxx] as first predicate", m_sourceObject);
valid = false;
}
} else {
m_validationContext.addError("Invalid predicate in path expression", m_sourceObject);
valid = false;
}
}
} else {
m_validationContext.addError("Invalid predicate in path expression", m_sourceObject);
valid = false;
}
} else {
elemname = step;
}
// decode the position predicate
int position = -1;
if (valid && postext != null) {
position = convertPosition(postext);
valid = position > 0;
}
// return constructed step if syntax is valid
if (valid) {
return new PathStep(elemname, position, nameattr);
} else {
return null;
}
}
}
/**
* Find matches for expression starting from a supplied schema element.
*
* @param offset current path step offset
* @param end ending match list offset
* @param base starting element for match
* @param matches elements matching expression
*/
private void match(int offset, int end, OpenAttrBase base, ArrayList matches) {
LazyList childs = base.getChildrenWritable();
StepBase step = m_steps[offset];
int steppos = step.position();
int position = 0;
for (int i = 0; i < childs.size(); i++) {
OpenAttrBase child = (OpenAttrBase)childs.get(i);
if (step.match(child)) {
if (steppos <= 0 || steppos == ++position) {
if (offset == end) {
matches.add(child);
} else {
match(offset + 1, end, child, matches);
}
if (step.isRepeating()) {
match(offset, end, child, matches);
}
if (steppos > 0) {
break;
}
}
}
}
}
/**
* Get length of this path (minimum number of nested elements).
*
* @return path length
*/
public int getPathLength() {
return m_steps.length;
}
/**
* Check if the first path step is a wildcard.
*
* @return true if wildcard, false if not
*/
public boolean isWildStart() {
return m_steps[0] == WILDCARD_ELEMENT_STEP || m_steps[0] == WILDCARD_NESTING_STEP;
}
/**
* Find any number of matches for subexpression starting from a supplied schema element annotation.
*
* @param first starting path step index
* @param last ending path step index
* @param base starting element for match
* @return matching element, or null if error
*/
public List partialMatchMultiple(int first, int last, OpenAttrBase base) {
ArrayList matches = new ArrayList();
match(first, last, base, matches);
return matches;
}
/**
* Find unique match for subexpression starting from a supplied schema element annotation. An error is reported if
* no match is found, or if multiple matches are found.
*
* @param first starting path step index
* @param last ending path step index
* @param base starting element for match
* @return matching element, or null if error
*/
public OpenAttrBase partialMatchUnique(int first, int last, OpenAttrBase base) {
List matches = partialMatchMultiple(first, last, base);
OpenAttrBase match = null;
if (matches.size() == 0) {
m_validationContext.addError("No match found for path expression", m_sourceObject);
} else if (matches.size() > 1) {
m_validationContext.addError("Multiple matches found for path expression", m_sourceObject);
} else {
match = (OpenAttrBase)matches.get(0);
}
return match;
}
/**
* Find unique match for expression starting from a supplied schema element annotation. An error is reported if no
* match is found, or if multiple matches are found.
*
* @param base starting element for match
* @return matching element, or null if error
*/
public OpenAttrBase matchUnique(OpenAttrBase base) {
return partialMatchUnique(0, m_steps.length-1, base);
}
/**
* Build a path. If a path expression is supplied, the final path step in the expression must either not use an
* element name, or the element name must match the actual element supplied.
*
* @param path expression (null if none)
* @param elemname element name for final step in path
* @param nameattr name attribute (applied to final step in path, null if none)
* @param postext position (applied to final step in path, null if none)
* @param obj object defining the path
* @param vctx validation context
* @return constructed path, or null if error
*/
public static SchemaPath buildPath(String path, String elemname, String nameattr, String postext, Object obj,
ValidationContext vctx) {
// start by handling supplied values for final step predicates
SchemaPath inst = new SchemaPath(obj, vctx);
boolean valid = true;
int position = -1;
if (postext != null) {
position = inst.convertPosition(postext);
if (position < 0) {
valid = false;
}
}
if (nameattr != null && !inst.validateName(nameattr)) {
valid = false;
}
// check for only last step involved
StepBase[] steps;
if (path == null) {
steps = new StepBase[] { new PathStep(elemname, position, nameattr) };
} else {
// path supplied, process each step
ArrayList steplist = new ArrayList();
int base = 0;
int split;
while ((split = path.indexOf('/', base)) >= 0) {
StepBase step = inst.buildPathStep(path.substring(base, split));
base = split + 1;
if (step == null) {
valid = false;
} else {
steplist.add(step);
}
}
// check the final step
String steptext = path.substring(base);
if ("**".equals(steptext)) {
// add wildcard step, then create separate final step from attributes and name
steplist.add(WILDCARD_NESTING_STEP);
} else {
// strip element name from last path step, if present
if (steptext.startsWith(elemname)) {
steptext = steptext.substring(elemname.length());
}
// build the last path step from path
StepBase step = inst.buildPathStep(elemname + steptext);
if (step instanceof PathStep) {
// make sure all components match specified values
PathStep laststep = (PathStep)step;
if (!elemname.equals(laststep.m_elementName)) {
vctx.addError("Last path step must use no element name, or the specified element name", obj);
valid = false;
}
if (position <= 0) {
position = laststep.m_position;
} else if (laststep.m_position > 0 && position != laststep.m_position) {
vctx.addError("Position must not be used in last path step, or must match specified value",
obj);
valid = false;
}
if (nameattr == null) {
nameattr = laststep.m_name;
} else if (laststep.m_name != null && !nameattr.equals(laststep.m_name)) {
vctx.addError("Name atribute must not be used in last path step, or must match specified value",
obj);
valid = false;
}
}
}
// add generated final step combining specified values with those from path
steplist.add(new PathStep(elemname, position, nameattr));
steps = (StepBase[])steplist.toArray(new StepBase[steplist.size()]);
}
// return configured instance if valid
if (valid) {
inst.m_steps = steps;
return inst;
} else {
return null;
}
}
public abstract static class StepBase
{
public abstract boolean match(OpenAttrBase elem);
public abstract boolean isRepeating();
public abstract int position();
}
public static class PathStep extends StepBase
{
private final String m_elementName;
private final int m_position;
private final String m_name;
protected PathStep(String elemname, int position, String name) {
m_elementName = elemname;
m_position = position;
m_name = name;
}
public boolean isRepeating() {
return false;
}
public boolean match(OpenAttrBase elem) {
if (elem.name().equals(m_elementName)) {
if (m_name == null) {
return true;
} else if (elem instanceof INamed && m_name.equals(((INamed)elem).getName())) {
return true;
} else if (elem instanceof IReference) {
QName ref = ((IReference)elem).getRef();
return ref != null && m_name.equals(ref.getName());
} else {
return false;
}
} else {
return false;
}
}
public int position() {
return m_position;
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/AnnotationElement.java 0000644 0001750 0001750 00000007724 11062041202 027210 0 ustar twerner twerner /*
Copyright (c) 2006, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import java.util.ArrayList;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.support.Conversions;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Model component for annotation element.
*
* @author Dennis M. Sosnoski
*/
public class AnnotationElement extends OpenAttrBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "id" });
/** Mask bits for annotation item child elements. */
private long ITEMS_MASK = ELEMENT_MASKS[APPINFO_TYPE] |
ELEMENT_MASKS[DOCUMENTATION_TYPE];
//
// Instance data
/** Filtered list of annotation items. */
private final FilteredSegmentList m_itemsList;
/** "id" attribute value. */
private String m_id;
/** Annotation items. */
private ArrayList m_items;
/**
* Constructor.
*/
public AnnotationElement() {
super(ANNOTATION_TYPE);
m_itemsList = new FilteredSegmentList(getChildrenWritable(),
ITEMS_MASK, this);
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Access methods
/**
* Get list of annotation item (appInfo and/or documentation)
* child elements.
*
* @return list of attributes
*/
public FilteredSegmentList getItemsList() {
return m_itemsList;
}
/**
* Get "id" attribute value.
*
* @return id attribute value
*/
public String getId() {
return m_id;
}
/**
* Set "id" value for element.
*
* @param id id attribute value
*/
public void setId(String id) {
m_id = id;
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check for valid "id" attribute value
m_id = Conversions.deserializeNCName(m_id, vctx, this);
// continue with parent class prevalidation
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/SchemaBase.java 0000644 0001750 0001750 00000044336 11155422416 025574 0 ustar twerner twerner /*
* Copyright (c) 2006-2008 Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.elements;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import org.jibx.binding.model.EmptyArrayList;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.IXMLWriter;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.schema.IComponent;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Base class for all element structures in schema definition model. This just provides the linkages for the schema
* definition tree structure and related validation hooks, along with support for extra namespaces.
*
* @author Dennis M. Sosnoski
*/
public abstract class SchemaBase implements IComponent
{
//
// Element type definitions.
public static final int ALL_TYPE = 0;
public static final int ANNOTATION_TYPE = 1;
public static final int ANY_TYPE = 2;
public static final int ANYATTRIBUTE_TYPE = 3;
public static final int APPINFO_TYPE = 4;
public static final int ATTRIBUTE_TYPE = 5;
public static final int ATTRIBUTEGROUP_TYPE = 6;
public static final int CHOICE_TYPE = 7;
public static final int COMPLEXCONTENT_TYPE = 8;
public static final int COMPLEXTYPE_TYPE = 9;
public static final int DOCUMENTATION_TYPE = 10;
public static final int ELEMENT_TYPE = 11;
public static final int ENUMERATION_TYPE = 12;
public static final int EXTENSION_TYPE = 13;
public static final int FIELD_TYPE = 14;
public static final int FRACTIONDIGITS_TYPE = 15;
public static final int GROUP_TYPE = 16;
public static final int IMPORT_TYPE = 17;
public static final int INCLUDE_TYPE = 18;
public static final int KEY_TYPE = 19;
public static final int KEYREF_TYPE = 20;
public static final int LENGTH_TYPE = 21;
public static final int LIST_TYPE = 22;
public static final int MAXEXCLUSIVE_TYPE = 23;
public static final int MAXINCLUSIVE_TYPE = 24;
public static final int MAXLENGTH_TYPE = 25;
public static final int MINEXCLUSIVE_TYPE = 26;
public static final int MININCLUSIVE_TYPE = 27;
public static final int MINLENGTH_TYPE = 28;
public static final int NOTATION_TYPE = 29;
public static final int PATTERN_TYPE = 30;
public static final int REDEFINE_TYPE = 31;
public static final int RESTRICTION_TYPE = 32;
public static final int SCHEMA_TYPE = 33;
public static final int SELECTOR_TYPE = 34;
public static final int SEQUENCE_TYPE = 35;
public static final int SIMPLECONTENT_TYPE = 36;
public static final int SIMPLETYPE_TYPE = 37;
public static final int TOTALDIGITS_TYPE = 38;
public static final int UNION_TYPE = 39;
public static final int UNIQUE_TYPE = 40;
public static final int WHITESPACE_TYPE = 41;
/** Actual element names. */
public static final String[] ELEMENT_NAMES;
/** Bit masks for individual elements. */
public static final long[] ELEMENT_MASKS;
static {
ELEMENT_NAMES = new String[WHITESPACE_TYPE + 1];
ELEMENT_NAMES[ALL_TYPE] = "all";
ELEMENT_NAMES[ANNOTATION_TYPE] = "annotation";
ELEMENT_NAMES[ANY_TYPE] = "any";
ELEMENT_NAMES[ANYATTRIBUTE_TYPE] = "anyAttribute";
ELEMENT_NAMES[APPINFO_TYPE] = "appinfo";
ELEMENT_NAMES[ATTRIBUTE_TYPE] = "attribute";
ELEMENT_NAMES[ATTRIBUTEGROUP_TYPE] = "attributeGroup";
ELEMENT_NAMES[CHOICE_TYPE] = "choice";
ELEMENT_NAMES[COMPLEXCONTENT_TYPE] = "complexContent";
ELEMENT_NAMES[COMPLEXTYPE_TYPE] = "complexType";
ELEMENT_NAMES[DOCUMENTATION_TYPE] = "documentation";
ELEMENT_NAMES[ELEMENT_TYPE] = "element";
ELEMENT_NAMES[ENUMERATION_TYPE] = "enumeration";
ELEMENT_NAMES[EXTENSION_TYPE] = "extension";
ELEMENT_NAMES[FIELD_TYPE] = "field";
ELEMENT_NAMES[FRACTIONDIGITS_TYPE] = "fractionDigits";
ELEMENT_NAMES[GROUP_TYPE] = "group";
ELEMENT_NAMES[IMPORT_TYPE] = "import";
ELEMENT_NAMES[INCLUDE_TYPE] = "include";
ELEMENT_NAMES[KEY_TYPE] = "key";
ELEMENT_NAMES[KEYREF_TYPE] = "keyref";
ELEMENT_NAMES[LENGTH_TYPE] = "length";
ELEMENT_NAMES[LIST_TYPE] = "list";
ELEMENT_NAMES[MAXEXCLUSIVE_TYPE] = "maxExclusive";
ELEMENT_NAMES[MAXINCLUSIVE_TYPE] = "maxInclusive";
ELEMENT_NAMES[MAXLENGTH_TYPE] = "maxLength";
ELEMENT_NAMES[MINEXCLUSIVE_TYPE] = "minExclusive";
ELEMENT_NAMES[MININCLUSIVE_TYPE] = "minInclusive";
ELEMENT_NAMES[MINLENGTH_TYPE] = "minLength";
ELEMENT_NAMES[NOTATION_TYPE] = "notation";
ELEMENT_NAMES[PATTERN_TYPE] = "pattern";
ELEMENT_NAMES[REDEFINE_TYPE] = "redefine";
ELEMENT_NAMES[RESTRICTION_TYPE] = "restriction";
ELEMENT_NAMES[SCHEMA_TYPE] = "schema";
ELEMENT_NAMES[SELECTOR_TYPE] = "selector";
ELEMENT_NAMES[SEQUENCE_TYPE] = "sequence";
ELEMENT_NAMES[SIMPLECONTENT_TYPE] = "simpleContent";
ELEMENT_NAMES[SIMPLETYPE_TYPE] = "simpleType";
ELEMENT_NAMES[TOTALDIGITS_TYPE] = "totalDigits";
ELEMENT_NAMES[UNION_TYPE] = "union";
ELEMENT_NAMES[UNIQUE_TYPE] = "unique";
ELEMENT_NAMES[WHITESPACE_TYPE] = "whiteSpace";
ELEMENT_MASKS = new long[ELEMENT_NAMES.length];
long mask = 1;
for (int i = 0; i < ELEMENT_NAMES.length; i++) {
if (ELEMENT_NAMES[i] == null) {
throw new RuntimeException("Array not properly initialized for index " + i);
}
ELEMENT_MASKS[i] = mask;
mask <<= 1;
}
};
//
// Instance data.
/** Element type code. */
private final int m_type;
/** Parent element. */
private OpenAttrBase m_parent;
/** Extension data for application use. */
private Object m_extension;
/**
* Namespace definitions associated with this element (lazy create, null if unused).
*/
private ArrayList m_namespaces;
/**
* Constructor.
*
* @param type element type code
*/
protected SchemaBase(int type) {
m_type = type;
}
/**
* Get element type.
*
* @return type code for this element
*/
public final int type() {
return m_type;
}
/**
* Get element name.
*
* @return type code for this element
*/
public final String name() {
return ELEMENT_NAMES[m_type];
}
/**
* Get element bit mask.
*
* @return bit mask for this element
*/
public final long bit() {
return ELEMENT_MASKS[m_type];
}
/**
* Get parent element.
*
* @return parent element, null if none (schema element only)
*/
public final OpenAttrBase getParent() {
return m_parent;
}
/**
* Set parent element. This method is provided for use by subclasses and other classes in this package (particularly
* {@link FilteredSegmentList}).
*
* @param parent
*/
protected final void setParent(OpenAttrBase parent) {
m_parent = parent;
}
/**
* Get the ancestor schema element. It is an error to call this method with an element which is not part of a
* schema, resulting in a runtime exception.
*
* @return schema
*/
public final SchemaElement getSchema() {
SchemaBase element = this;
while (element.type() != SCHEMA_TYPE) {
element = element.m_parent;
if (element == null) {
throw new IllegalStateException("Internal error - no ancestor schema element");
}
}
return (SchemaElement)element;
}
/**
* Check if this element represents a global definition.
*
* @return true if global, false if not
*/
public final boolean isGlobal() {
return m_parent instanceof SchemaElement;
}
/**
* Get extension data. The actual type of object used for extension data (if any) is defined by the application.
*
* @return extension
*/
public Object getExtension() {
return m_extension;
}
/**
* Set extension data. The actual type of object used for extension data (if any) is defined by the application.
*
* @param extension
*/
public void setExtension(Object extension) {
m_extension = extension;
}
/**
* Get namespace declarations list. Entries in this list consist of pairs, consisting of namespace prefix followed
* by namespace URI. The empty string is used as the prefix for the default namespace.
*
* @return extra attribute list
*/
public final ArrayList getNamespaceDeclarations() {
if (m_namespaces == null || m_namespaces.size() == 0) {
return EmptyArrayList.INSTANCE;
} else {
return m_namespaces;
}
}
/**
* Clear namespace declarations list.
*/
public final void clearNamespaceDeclarations() {
if (m_namespaces != null) {
m_namespaces.clear();
}
}
/**
* Add namespace declaration.
*
* @param prefix namespace prefix
* @param uri namespace URI
*/
public final void addNamespaceDeclaration(String prefix, String uri) {
if (m_namespaces == null) {
m_namespaces = new ArrayList();
}
m_namespaces.add(prefix);
m_namespaces.add(uri);
}
/**
* Get count of child elements.
*
* @return child count
*/
public abstract int getChildCount();
/**
* Get read-only iterator for child elements.
*
* @return iterator
*/
public abstract Iterator getChildIterator();
/**
* Pre-get method to be called by data binding while writing element start tag. The base class implementation just
* writes out any extra namespaces defined on the element. Subclasses which override this implementation must call
* the base implementation during their processing.
*
* @param ictx marshalling context
* @throws JiBXException on marshalling error
*/
protected void preget(IMarshallingContext ictx) throws JiBXException {
writeNamespaces(ictx);
}
/**
* Pre-set method to be called by data binding while parsing element start tag. The base class implementation just
* sets the parent element link and reads in any extra namespaces defined on the element. Subclasses which override
* this implementation must call the base implementation during their processing.
*
* @param ictx unmarshalling context
* @throws JiBXException on error
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
Object parent = ictx.getStackTop();
if (parent instanceof Collection) {
parent = ictx.getStackObject(1);
}
if (parent instanceof OpenAttrBase) {
m_parent = (OpenAttrBase)parent;
}
readNamespaces(ictx);
}
/**
* Validate attributes of element. This is designed to be called during unmarshalling as part of the pre-set method
* processing when a subclass instance is being created.
*
* @param ictx unmarshalling context
* @param extra allow extra attributes from other namespaces flag
* @param attrs attributes array
* @see #preset(IUnmarshallingContext)
*/
protected static void validateAttributes(IUnmarshallingContext ictx, boolean extra, StringArray attrs) {
// loop through all attributes of current element
UnmarshallingContext uctx = (UnmarshallingContext)ictx;
for (int i = 0; i < uctx.getAttributeCount(); i++) {
String name = uctx.getAttributeName(i);
String ns = uctx.getAttributeNamespace(i);
if (ns == null || ns.length() == 0) {
// check if schema attribute in allowed set
if (attrs.indexOf(name) < 0) {
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
vctx.addError("Undefined attribute " + name, ictx.getStackTop());
}
} else if (SCHEMA_NAMESPACE.equals(ns)) {
// no attributes from schema namespace are defined
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
vctx.addError("Undefined attribute " + name, ictx.getStackTop());
} else if (!extra) {
// warn on non-schema attribute present where forbidden
ValidationContext vctx = (ValidationContext)ictx.getUserContext();
String qname = UnmarshallingContext.buildNameString(ns, name);
vctx.addWarning("Non-schema attribute not allowed " + qname, ictx.getStackTop());
}
}
}
/**
* Collect namespace declarations from element. This is designed to be called during unmarshalling as part of the
* pre-set method processing when a subclass instance is being created.
*
* @param ictx unmarshalling context
*/
protected void readNamespaces(IUnmarshallingContext ictx) {
UnmarshallingContext ctx = (UnmarshallingContext)ictx;
int count = ctx.getNamespaceCount();
if (count > 0) {
m_namespaces = new ArrayList();
for (int i = 0; i < count; i++) {
String pref = ctx.getNamespacePrefix(i);
if (pref == null) {
pref = "";
}
if (pref.equals("xs")) {
if (SCHEMA_NAMESPACE.equals(ctx.getNamespaceUri(i))) {
continue;
} else {
throw new RuntimeException("Cannot handle 'xs' prefix associated with non-schema namespace");
}
}
m_namespaces.add(pref);
m_namespaces.add(ctx.getNamespaceUri(i));
}
} else {
m_namespaces = null;
}
}
/**
* Write namespace declarations to element. This is designed to be called during marshalling as part of the pre-get
* method processing when a subclass instance is being marshalled.
*
* @param ictx marshalling context
* @throws JiBXException on error writing
*/
protected void writeNamespaces(IMarshallingContext ictx) throws JiBXException {
if (m_namespaces != null) {
try {
// set up information for namespace indexes and prefixes
IXMLWriter writer = ictx.getXmlWriter();
String[] uris = new String[m_namespaces.size() / 2];
int[] indexes = new int[uris.length];
String[] prefs = new String[uris.length];
int base = writer.getNamespaceCount();
for (int i = 0; i < uris.length; i++) {
indexes[i] = base + i;
prefs[i] = (String)m_namespaces.get(i * 2);
uris[i] = (String)m_namespaces.get(i * 2 + 1);
}
// add the namespace declarations to current element
writer.pushExtensionNamespaces(uris);
writer.openNamespaces(indexes, prefs);
for (int i = 0; i < uris.length; i++) {
String prefix = prefs[i];
String name = prefix.length() > 0 ? "xmlns:" + prefix : "xmlns";
writer.addAttribute(0, name, uris[i]);
}
} catch (IOException e) {
throw new JiBXException("Error writing output document", e);
}
}
}
/**
* Prevalidate component information. The prevalidation step is used to check isolated aspects of a component, such
* as the settings for enumerated values. This empty base class implementation should be overridden by each subclass
* that requires prevalidation handling.
*
* @param vctx validation context
*/
public void prevalidate(ValidationContext vctx) {}
/**
* Validate component information. The validation step is used for checking the interactions between components,
* such as name references to other components. The {@link #prevalidate} method will always be called for every
* component in the schema definition before this method is called for any component. This empty base class
* implementation should be overridden by each subclass that requires validation handling.
*
* @param vctx validation context
*/
public void validate(ValidationContext vctx) {}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/CommonCompositorDefinition.java 0000644 0001750 0001750 00000006226 10624256130 031113 0 ustar twerner twerner /*
Copyright (c) 2006-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
/**
* Compositor for complex content model, including the special case of <all>.
* The subclasses implement the different models for how nested particles are
* combined.
*
* @author Dennis M. Sosnoski
*/
public abstract class CommonCompositorDefinition extends CommonCompositorBase
{
/** Mask for child elements allowed by <choice> and <sequence>. */
protected static long CHOICE_SEQUENCE_PARTICLE_MASK =
ELEMENT_MASKS[ANY_TYPE] | ELEMENT_MASKS[CHOICE_TYPE] |
ELEMENT_MASKS[ELEMENT_TYPE] | ELEMENT_MASKS[GROUP_TYPE] |
ELEMENT_MASKS[SEQUENCE_TYPE];
//
// Instance data
/** Filtered list of composited particle elements. */
private final FilteredSegmentList m_particleList;
/**
* Constructor.
*
* @param type element type
* @param mask mask for allowed particle elements
*/
protected CommonCompositorDefinition(int type, long mask) {
super(type);
m_particleList = new FilteredSegmentList(getChildrenWritable(),
mask, this);
}
//
// Access methods
/**
* Get list of composited particles.
*
* @return list
*/
public FilteredSegmentList getParticleList() {
return m_particleList;
}
//
// Overrides of base class methods
/* (non-Javadoc)
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/FilteredSegmentList.java 0000644 0001750 0001750 00000023204 11062041174 027500 0 ustar twerner twerner /*
Copyright (c) 2006, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import java.util.AbstractList;
import org.jibx.util.LazyList;
/**
* Virtual list generated from a backing list by filtering on the element types.
* This exposes a segment of the backing list through the filter, with multiple
* filters used to expose the entire backing list piecemeal. It can only be used
* with lists of elements.
*
* @author Dennis M. Sosnoski
*/
public class FilteredSegmentList extends AbstractList
{
/** Base list. */
private final LazyList m_list;
/** Mask for element types to match in filter. */
private final long m_matchBits;
/** Filter for elements prior to this filter in list. */
private final FilteredSegmentList m_prior;
/** Element owning this list. */
private final OpenAttrBase m_owner;
/** Last modify count matching cached values. */
private int m_lastModify;
/** Cached filtered list start index in base list. */
private int m_startIndex;
/** Cached size of filtered list. */
private int m_size;
/**
* Dummy default constructor for unmarshalling.
*/
private FilteredSegmentList() {
throw new IllegalStateException("Default constructor is not valid");
}
/**
* Constructor with everything specified.
*
* @param list backing list
* @param match included element types mask
* @param prior filter which comes before this one (null if
* none)
* @param owner element owning this list
*/
public FilteredSegmentList(LazyList list, long match,
FilteredSegmentList prior, OpenAttrBase owner) {
if (owner == null) {
throw new IllegalArgumentException("Internal error - list must have owner");
}
m_list = list;
m_matchBits = match;
m_prior = prior;
m_owner = owner;
m_lastModify = -1;
}
/**
* Constructor with no prior filter.
*
* @param list backing list
* @param match included element types mask
* @param owner element owning this list
*/
public FilteredSegmentList(LazyList list, long match, OpenAttrBase owner) {
this(list, match, null, owner);
}
/**
* Update modify count to show cached state is current. This propagates to
* any prior filter(s).
*/
private void setModify() {
m_lastModify = m_list.getModCount();
if (m_prior != null) {
m_prior.setModify();
}
}
/**
* Synchronize filter to current list state. If the cached state is not
* current this updates the cached state to reflect the current state of the
* backing list.
*/
private void sync() {
if (m_lastModify != m_list.getModCount()) {
// updating cache, first update preceding filters
if (m_prior == null) {
m_startIndex = 0;
} else {
m_prior.sync();
m_startIndex = m_prior.m_startIndex + m_prior.m_size;
}
// scan through list to find end of items included by this filter
int index = m_startIndex;
while (index < m_list.size()) {
SchemaBase item = (SchemaBase)m_list.get(index);
if ((item.bit() & m_matchBits) != 0) {
index++;
} else {
break;
}
}
m_size = index - m_startIndex;
// update modify count for cached state
m_lastModify = m_list.getModCount();
}
}
/* (non-Javadoc)
* @see java.util.AbstractList#get(int)
*/
public Object get(int index) {
sync();
if (index >= 0 && index < m_size) {
return m_list.get(m_startIndex + index);
} else {
throw new IndexOutOfBoundsException("Index " + index +
" is out of valid range 0-" + (m_size-1));
}
}
/* (non-Javadoc)
* @see java.util.AbstractCollection#size()
*/
public int size() {
sync();
return m_size;
}
/* (non-Javadoc)
* @see java.util.AbstractList#add(int, java.lang.Object)
*/
public void add(int index, Object element) {
sync();
if (index >= 0 && index <= m_size) {
// make sure added element is allowed by this filter
SchemaBase item = (SchemaBase)element;
if ((item.bit() & m_matchBits) != 0) {
// add the element into backing list
m_list.add(m_startIndex + index, item);
// set parent link for element
item.setParent(m_owner);
// mark this and prior filters as current
m_size++;
setModify();
modCount++;
} else {
throw new IllegalArgumentException("Element of type \"" +
item.name() + "\" is not allowed by filter");
}
} else {
throw new IndexOutOfBoundsException("Index " + index +
" is out of valid range 0-" + m_size);
}
}
/**
* Removes the item at the index position.
*
* @param index
* @return removed item
*/
public Object remove(int index) {
sync();
if (index >= 0 && index < m_size) {
// remove the element from backing list
Object item = m_list.remove(m_startIndex + index);
((SchemaBase)item).setParent(null);
// mark this and prior filters as current
m_size--;
setModify();
modCount++;
return item;
} else {
throw new IndexOutOfBoundsException("Index " + index +
" is out of valid range 0-" + (m_size-1));
}
}
/* (non-Javadoc)
* @see java.util.AbstractCollection#remove(java.lang.Object)
*/
public boolean remove(Object o) {
sync();
for (int i = 0; i < m_size; i++) {
if (m_list.get(m_startIndex + i) == o) {
m_list.remove(m_startIndex + i);
((SchemaBase)o).setParent(null);
m_size--;
setModify();
modCount++;
return true;
}
}
return false;
}
/* (non-Javadoc)
* @see java.util.AbstractList#set(int, java.lang.Object)
*/
public Object set(int index, Object element) {
sync();
if (index >= 0 && index < m_size) {
// make sure replacement element is allowed by this filter
SchemaBase item = (SchemaBase)element;
if ((item.bit() & m_matchBits) != 0) {
// set the element in backing list
item.setParent(m_owner);
Object prior = m_list.set(m_startIndex + index, item);
((SchemaBase)prior).setParent(null);
return prior;
} else {
throw new IllegalArgumentException("Element of type \"" +
item.name() + "\" is not allowed by filter");
}
} else {
throw new IndexOutOfBoundsException("Index " + index +
" is out of valid range 0-" + (m_size-1));
}
}
/* (non-Javadoc)
* @see java.util.AbstractList#removeRange(int, int)
*/
protected void removeRange(int from, int to) {
sync();
if (from >= 0 && to <= m_size) {
// clear the parent linkages
for (int i = from; i < to; i++) {
((SchemaBase)m_list.get(i)).setParent(null);
}
// delete all items from underlying list
m_list.remove(from, to);
// mark this and prior filters as current
m_size -= to - from;
setModify();
modCount++;
} else {
throw new IndexOutOfBoundsException("Range of " + from + "-" + to +
" exceeds valid range 0-" + m_size);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/OpenAttrBase.java 0000644 0001750 0001750 00000020630 11124147712 026116 0 ustar twerner twerner /*
Copyright (c) 2006, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.jibx.binding.model.EmptyArrayList;
import org.jibx.runtime.IMarshallingContext;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.IXMLWriter;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.impl.UnmarshallingContext;
import org.jibx.util.LazyList;
import org.jibx.util.StringArray;
/**
* Base class for all element structures in schema definition which allow
* arbitrary attributes from outside the schema namespace.
*
* @author Dennis M. Sosnoski
*/
public abstract class OpenAttrBase extends SchemaBase
{
/** Child element list (lazy create, null if not used) */
private LazyList m_children;
/** Extra attributes associated with element (lazy create,
null if unused). */
private ArrayList m_attributes;
/**
* Constructor.
*
* @param type element type
*/
protected OpenAttrBase(int type) {
super(type);
m_children = new LazyList();
}
//
// Base class overrides
/**
* Get count of child elements.
*
* @return child count
*/
public final int getChildCount() {
return m_children.size();
}
/**
* Get read-only iterator for child elements.
*
* @return iterator
*/
public Iterator getChildIterator() {
return m_children.iterator();
}
/**
* Get child by index.
*
* @param index
* @return child element
*/
public SchemaBase getChild(int index) {
return (SchemaBase)m_children.get(index);
}
/**
* Replace child by index.
*
* @param index
* @param repl replacement element
* @return detached child
*/
public SchemaBase replaceChild(int index, SchemaBase repl) {
SchemaBase child = (SchemaBase)m_children.get(index);
repl.setParent(this);
m_children.set(index, repl);
return child;
}
/**
* Detach child by index. This method only replaces the child with a null in the child list, leaving
* the list in an illegal state for most purposes. After using this method, {@link #compactChildren()} must be
* called to remove the null(s) from the list and restore it to a legal state. These methods are
* provided to avoid the overhead otherwise associated with multiple removals from a list.
*
* @param index
* @return detached child
*/
public SchemaBase detachChild(int index) {
SchemaBase child = (SchemaBase)m_children.get(index);
m_children.set(index, null);
return child;
}
/**
* Compact the list of child elements. This removes any null values (which should only be present if
* {@link #detachChild(int)} was called) from the list.
*/
public void compactChildren() {
m_children.compact();
}
/**
* Pre-get method called during marshalling. This first calls the base
* class implementation to handle namespaces, then writes any extra
* attributes to the element start tag.
*
* @param ictx marshalling context
*/
protected void preget(IMarshallingContext ictx) throws JiBXException {
// call base class implementation to handle namespaces
super.preget(ictx);
// write all extra attributes to element start tag
if (m_attributes != null) {
IXMLWriter writer = ictx.getXmlWriter();
for (int i = 0; i < m_attributes.size();) {
String name = (String) m_attributes.get(i++);
String uri = (String) m_attributes.get(i++);
String value = (String) m_attributes.get(i++);
int index = writer.getNamespaceCount();
while (--index >= 0 &&
!uri.equals(writer.getNamespaceUri(index)));
if (index >= 0) {
try {
writer.addAttribute(index, name, value);
} catch (IOException e) {
throw new JiBXException("Error writing attribute", e);
}
} else {
throw new JiBXException("Namespace uri \"" + uri +
"\" is not defined");
}
}
}
}
//
// Access methods
/**
* Get modifiable list of child elements. This method should only be used by
* subclasses to work with their own list of child elements.
*
* @return child list
*/
protected final LazyList getChildrenWritable() {
return m_children;
}
/**
* Get read-only list of extra attributes. Entries in this list are
* triplets, consisting of attribute name, namespace, and value.
*
* @return extra attribute list
*/
public final List getExtraAttributes() {
if (m_attributes == null || m_attributes.size() == 0) {
return EmptyArrayList.INSTANCE;
} else {
return Collections.unmodifiableList(m_attributes);
}
}
/**
* Clear extra attribute list.
*/
public final void clearExtraAttributes() {
if (m_attributes != null) {
m_attributes.clear();
}
}
/**
* Add extra attribute.
*
* @param name attribute name
* @param uri attribute namespace URI
* @param value attribute value
*/
public final void addExtraAttribute(String name, String uri, String value) {
if (m_attributes == null) {
m_attributes = new ArrayList();
}
m_attributes.add(name);
m_attributes.add(uri);
m_attributes.add(value);
}
//
// Validation methods
/**
* Validate attributes of element from schema namespace. This allows any
* number of attributes from other namespaces on the element.
*
* @param ictx unmarshalling context
* @param attrs attributes array
* @exception JiBXException on unmarshalling error
*/
protected void validateAttributes(IUnmarshallingContext ictx,
StringArray attrs) throws JiBXException {
// handle basic validation
readNamespaces(ictx);
validateAttributes(ictx, true, attrs);
// loop through all attributes of current element
UnmarshallingContext uctx = (UnmarshallingContext)ictx;
clearExtraAttributes();
for (int i = 0; i < uctx.getAttributeCount(); i++) {
// collect attributes from non-schema namespaces
String ns = uctx.getAttributeNamespace(i);
if (ns != null && ns.length() > 0 && !SCHEMA_NAMESPACE.equals(ns)) {
addExtraAttribute(uctx.getAttributeName(i), ns,
uctx.getAttributeValue(i));
}
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/AnyAttributeElement.java 0000644 0001750 0001750 00000004340 10602646264 027522 0 ustar twerner twerner /*
* Copyright (c) 2006, Dennis M. Sosnoski 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. Neither the name of JiBX nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
/**
* anyAttribute element definition.
*
* @author Dennis M. Sosnoski
*/
public class AnyAttributeElement extends WildcardBase
{
/**
* Constructor.
*/
public AnyAttributeElement() {
super(ANYATTRIBUTE_TYPE);
}
//
// Base class overrides
/*
* (non-Javadoc)
*
* @see org.jibx.binding.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, WildcardBase.s_allowedAttributes);
super.preset(ictx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/RedefineElement.java 0000644 0001750 0001750 00000005651 11125561374 026635 0 ustar twerner twerner /*
Copyright (c) 2006-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import java.util.ArrayList;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.util.StringArray;
/**
* Model component for redefine element.
*
* @author Dennis M. Sosnoski
*/
public class RedefineElement extends SchemaLocationRequiredBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "id" },
SchemaLocationBase.s_allowedAttributes);
/** "id" attribute value. */
private String m_id;
/** Redefinition body. */
private ArrayList m_content;
/**
* Constructor.
*/
public RedefineElement() {
super(REDEFINE_TYPE);
}
//
// Access methods
public String getId() {
return m_id;
}
public void setId(String id) {
m_id = id;
}
public ArrayList getContents() {
return m_content;
}
public void clearContents() {
m_content.clear();
}
public void addContent(SchemaBase element) {
m_content.add(element);
}
//
// Base class overrides
protected String getEffectiveNamespace() {
return getSchema().getEffectiveNamespace();
}
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/IncludeElement.java 0000644 0001750 0001750 00000004211 11125561374 026466 0 ustar twerner twerner /*
Copyright (c) 2006-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
/**
* Model component for include element.
*
* @author Dennis M. Sosnoski
*/
public class IncludeElement extends SchemaLocationRequiredBase
{
/**
* Constructor.
*/
public IncludeElement() {
super(INCLUDE_TYPE);
}
//
// Base class overrides
protected String getEffectiveNamespace() {
return getSchema().getEffectiveNamespace();
}
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/AttributeGroupElement.java 0000644 0001750 0001750 00000013053 11062041164 030055 0 ustar twerner twerner /*
Copyright (c) 2006-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.schema.INamed;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Top-level group element definition.
*
* @author Dennis M. Sosnoski
*/
public class AttributeGroupElement extends AnnotatedBase implements INamed
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "name" },
AnnotatedBase.s_allowedAttributes);
/** Mask bits for attribute child elements. */
private long ATTRIBUTE_MASK = ELEMENT_MASKS[ATTRIBUTE_TYPE] |
ELEMENT_MASKS[ATTRIBUTEGROUP_TYPE];
/** Mask bits for any attribute child elements. */
private long ANYATTRIBUTE_MASK = ELEMENT_MASKS[ANYATTRIBUTE_TYPE];
//
// Instance data
/** Filtered list of attribute definitions. */
private final FilteredSegmentList m_attributeList;
/** Filtered list of anyAttribute definition (zero or one). */
private final FilteredSegmentList m_anyAttributeList;
/** 'name' attribute value. */
private String m_name;
/** Qualified name (only defined after validation). */
private QName m_qname;
/**
* Constructor.
*/
public AttributeGroupElement() {
super(ATTRIBUTEGROUP_TYPE);
m_attributeList = new FilteredSegmentList(getChildrenWritable(),
ATTRIBUTE_MASK, this);
m_anyAttributeList = new FilteredSegmentList(getChildrenWritable(),
ANYATTRIBUTE_MASK, m_attributeList, this);
}
//
// Access methods
/**
* Get 'name' attribute value.
*
* @return name
*/
public String getName() {
return m_name;
}
/**
* Set 'name' attribute value.
*
* @param name
*/
public void setName(String name) {
m_name = name;
}
/**
* Get qualified name for element. This method is only usable after
* prevalidation.
*
* @return qname (null if not defined)
*/
public QName getQName() {
return m_qname;
}
/**
* Get list of attribute and attributeGroup child elements.
*
* @return list of attributes
*/
public FilteredSegmentList getAttributeList() {
return m_attributeList;
}
/**
* Get anyAttribute child element.
*
* @return element, or null if none
*/
public AnyAttributeElement getAnyAttribute() {
return m_anyAttributeList.size() > 0 ?
(AnyAttributeElement)m_anyAttributeList.get(0) : null;
}
/**
* Set anyAttribute child element.
*
* @param element element, or null if unsetting
*/
public void setAnyAttribute(AnyAttributeElement element) {
m_anyAttributeList.clear();
if (element != null) {
m_anyAttributeList.add(element);
}
}
//
// Overrides of base class methods
/* (non-Javadoc)
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check for missing items
if (m_name == null) {
vctx.addError("Missing required 'name' attribute", this);
} else {
m_qname = new QName(vctx.getCurrentSchema().getEffectiveNamespace(),
getName());
}
if (m_anyAttributeList.size() > 1) {
vctx.addError("Only one child allowed", this);
}
// continue with parent class prevalidation
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/CommonTypeDerivation.java 0000644 0001750 0001750 00000011470 11362416106 027710 0 ustar twerner twerner /*
Copyright (c) 2006-2010, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.QName;
import org.jibx.schema.support.QNameConverter;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Base class for all extension and restriction element
* variations.
*
* @author Dennis M. Sosnoski
*/
public abstract class CommonTypeDerivation extends AnnotatedBase
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes = new StringArray(
new String[] { "base" }, AnnotatedBase.s_allowedAttributes);
//
// Instance data
/** 'base' attribute value. */
private QName m_base;
/** Referenced type definition (null if none). */
private CommonTypeDefinition m_typeDef;
/**
* Constructor.
*
* @param type actual element type
*/
protected CommonTypeDerivation(int type) {
super(type);
}
//
// Access methods
/**
* Get 'base' attribute value.
*
* @return attribute value
*/
public QName getBase() {
return m_base;
}
/**
* Set 'base' attribute value.
*
* @param base attribute value
*/
public void setBase(QName base) {
m_base = base;
}
/**
* Get the base type definition. This method is only usable after
* validation.
*
* @return base type
*/
public CommonTypeDefinition getBaseType() {
return m_typeDef;
}
/**
* Check if complex type derivation.
*
* @return true if complex type derivation, false
* if simple type derivation
*/
public abstract boolean isComplexType();
/**
* Check if extension derivation.
*
* @return true if extension, false if restriction
*/
public abstract boolean isExtension();
//
// Validation methods
/**
* Check if base attribute value is required for this element. This allows
* subclasses to override the default required status.
*
* @return true if base attribute required, false
* if not
*/
protected boolean isBaseRequired() {
return true;
}
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
if (getBase() == null) {
if (isBaseRequired()) {
vctx.addError("The 'base' attribute is required for an extension or restriction", this);
}
} else {
SchemaElement schema = vctx.getCurrentSchema();
String ens = schema.getEffectiveNamespace();
QNameConverter.patchQNameNamespace(ens, m_base);
}
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ComponentBase#validate(org.jibx.schema.ValidationContext)
*/
public void validate(ValidationContext vctx) {
// look up referenced type definition
if (m_base != null) {
m_typeDef = vctx.findType(m_base);
}
if (isBaseRequired() && m_typeDef == null) {
vctx.addFatal("Referenced type '" + m_base + "' is not defined", this);
}
// continue with parent class validation
super.validate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/ChoiceElement.java 0000644 0001750 0001750 00000003507 10624256126 026303 0 ustar twerner twerner /*
Copyright (c) 2006-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
/**
* <choice> element definition. This is just a trivial variation of the base
* compositor class.
*
* @author Dennis M. Sosnoski
*/
public class ChoiceElement extends CommonCompositorDefinition
{
/**
* Constructor.
*/
public ChoiceElement() {
super(CHOICE_TYPE, CHOICE_SEQUENCE_PARTICLE_MASK);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/ComplexRestrictionElement.java 0000644 0001750 0001750 00000003762 10673572516 030761 0 ustar twerner twerner /*
Copyright (c) 2006-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
/**
* Definition for restriction element used with a complex type.
*
* @author Dennis M. Sosnoski
*/
public class ComplexRestrictionElement extends CommonComplexModification
{
/**
* Constructor.
*/
protected ComplexRestrictionElement() {
super(RESTRICTION_TYPE);
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.elements.CommonTypeDerivation#isExtension()
*/
public boolean isExtension() {
return false;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/WildcardBase.java 0000644 0001750 0001750 00000010764 11062041166 026117 0 ustar twerner twerner /*
* Copyright (c) 2006, Dennis M. Sosnoski 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. Neither the name of JiBX nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.support.Conversions;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Base for wildcard element definitions.
*
* @author Dennis M. Sosnoski
*/
public class WildcardBase extends AnnotatedBase
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes = new StringArray(
new String[] { "namespace", "processContents" },
AnnotatedBase.s_allowedAttributes);
//
// Value set information
public static final int LAX_PROCESS = 0;
public static final int SKIP_PROCESS = 1;
public static final int STRICT_PROCESS = 2;
public static final EnumSet s_processValues = new EnumSet(LAX_PROCESS,
new String[] { "lax", "skip", "strict" });
//
// Instance data
/** 'namespace' attribute value. */
private String[] m_namespaces;
/** 'processContents' attribute value. */
private int m_processType;
/**
* Constructor.
*
* @param type element type
*/
public WildcardBase(int type) {
super(type);
m_processType = -1;
}
//
// Accessor methods
/**
* Get 'namespace' attribute value.
*
* @return namespaces
*/
public String[] getNamespaces() {
return m_namespaces;
}
/**
* Set 'namespace' attribute value.
*
* @param namespaces
*/
public void setNamespaces(String[] namespaces) {
m_namespaces = namespaces;
}
/**
* Get 'processContents' attribute type code.
*
* @return code (-1 if not set)
*/
public int getProcessContents() {
return m_processType;
}
/**
* Set 'processContents' attribute type code.
*
* @param code (-1 to unset)
*/
public void setProcessContents(int code) {
if (code >= 0) {
s_processValues.checkValue(code);
}
m_processType = code;
}
/**
* Get 'processContents' attribute text.
*
* @return text (null if not set)
*/
public String getProcessContentsText() {
return s_processValues.getName(m_processType);
}
/**
* Set 'processContents' attribute text. This method is provided only for
* use when unmarshalling.
*
* @param text
* @param ictx
*/
private void setProcessContentsText(String text,
IUnmarshallingContext ictx) {
m_processType = Conversions.convertEnumeration(text, s_processValues,
"use", ictx);
}
//
// Validation methods
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// TODO check namespace list
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/SimpleRestrictionElement.java 0000644 0001750 0001750 00000013052 11362401204 030551 0 ustar twerner twerner /*
Copyright (c) 2006-2010, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.validation.ValidationContext;
/**
* restriction element definition used for simple content.
*
* @author Dennis M. Sosnoski
*/
public class SimpleRestrictionElement extends CommonSimpleModification
{
/** Mask bits for inline base type definition. */
private long INLINE_TYPE_MASK = ELEMENT_MASKS[SIMPLETYPE_TYPE];
/** Mask bits for facet child elements. */
private long FACETS_MASK = ELEMENT_MASKS[ENUMERATION_TYPE] |
ELEMENT_MASKS[FRACTIONDIGITS_TYPE] | ELEMENT_MASKS[LENGTH_TYPE] |
ELEMENT_MASKS[MAXEXCLUSIVE_TYPE] | ELEMENT_MASKS[MAXINCLUSIVE_TYPE] |
ELEMENT_MASKS[MAXLENGTH_TYPE] | ELEMENT_MASKS[MINEXCLUSIVE_TYPE] |
ELEMENT_MASKS[MININCLUSIVE_TYPE] | ELEMENT_MASKS[MINLENGTH_TYPE] |
ELEMENT_MASKS[PATTERN_TYPE] | ELEMENT_MASKS[TOTALDIGITS_TYPE] |
ELEMENT_MASKS[WHITESPACE_TYPE];
//
// Instance data
/** Filtered list of inline base type definition element. */
private final FilteredSegmentList m_inlineBaseList;
/** Filtered list of facet elements. */
private final FilteredSegmentList m_facetsList;
/**
* Constructor.
*/
public SimpleRestrictionElement() {
super(RESTRICTION_TYPE);
m_inlineBaseList = new FilteredSegmentList(getChildrenWritable(),
INLINE_TYPE_MASK, this);
m_facetsList = new FilteredSegmentList(getChildrenWritable(),
FACETS_MASK, m_inlineBaseList, this);
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.elements.CommonTypeDerivation#isComplexType()
*/
public boolean isComplexType() {
return false;
}
/* (non-Javadoc)
* @see org.jibx.schema.elements.CommonTypeDerivation#isExtension()
*/
public boolean isExtension() {
return false;
}
/* (non-Javadoc)
* @see org.jibx.binding.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Accessor methods
/**
* Get inline base type definition element.
*
* @return inline base type, or null if none
*/
public SimpleTypeElement getDerivation() {
return m_inlineBaseList.size() > 0 ?
(SimpleTypeElement)m_inlineBaseList.get(0) : null;
}
/**
* Set inline base type definition element.
*
* @param element inline base type, or null if unsetting
*/
public void setDerivation(SimpleTypeElement element) {
m_inlineBaseList.clear();
if (element != null) {
m_inlineBaseList.add(element);
}
}
/**
* Get list of child facet elements.
*
* @return list of facets
*/
public FilteredSegmentList getFacetsList() {
return m_facetsList;
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.elements.CommonTypeDerivation#isBaseRequired()
*/
protected boolean isBaseRequired() {
return false;
}
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check for missing or conflicting type information
if (m_inlineBaseList.size() == 0 && getBase() == null) {
vctx.addError("Must have 'base' attribute or inline definition", this);
}
if (m_inlineBaseList.size() > 0 && getBase() != null) {
vctx.addError("Can only use 'base' attribute without inline definition", this);
}
if (m_inlineBaseList.size() > 1) {
vctx.addError("Only one inline definition allowed", this);
}
// continue with parent class prevalidation
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/AppInfoElement.java 0000644 0001750 0001750 00000003310 11155044604 026431 0 ustar twerner twerner /*
Copyright (c) 2006-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
/**
* appinfo annotation item element.
*/
public class AppInfoElement extends AnnotationItem
{
/**
* Constructor.
*/
public AppInfoElement() {
super(APPINFO_TYPE);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/ComplexContentElement.java 0000644 0001750 0001750 00000006052 11062041166 030042 0 ustar twerner twerner /*
Copyright (c) 2006, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.util.StringArray;
/**
* Representation for a complexContent element.
*
* @author Dennis M. Sosnoski
*/
public class ComplexContentElement extends CommonContentBase
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "mixed" },
AnnotatedBase.s_allowedAttributes);
//
// Instance data
/** 'mixed' attribute value. */
private Boolean m_mixed;
/**
* Constructor.
*/
public ComplexContentElement() {
super(COMPLEXCONTENT_TYPE);
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.elements.CommonContentBase#isComplexContent()
*/
public boolean isComplexContent() {
return true;
}
/* (non-Javadoc)
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Access methods
/**
* Get 'mixed' attribute value.
*
* @return mixed (null if not set)
*/
public Boolean getMixed() {
return m_mixed;
}
/**
* Set 'mixed' attribute value.
*
* @param mixed (null if not set)
*/
public void setMixed(Boolean mixed) {
m_mixed = mixed;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/ComplexTypeElement.java 0000644 0001750 0001750 00000025141 11357411114 027352 0 ustar twerner twerner /*
Copyright (c) 2006-2010, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.types.AllEnumSet;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* complexType element definition.
*
* @author Dennis M. Sosnoski
*/
public class ComplexTypeElement extends CommonTypeDefinition
implements IComplexStructure
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "abstract", "block", "final", "mixed" },
CommonTypeDefinition.s_allowedAttributes);
/** Mask bits for content type child elements. */
private long CONTENT_TYPE_MASK = ELEMENT_MASKS[COMPLEXCONTENT_TYPE] |
ELEMENT_MASKS[SIMPLECONTENT_TYPE];
/** Mask bits for content definition child elements. */
private long CONTENT_DEFINITION_MASK = ELEMENT_MASKS[ALL_TYPE] |
ELEMENT_MASKS[CHOICE_TYPE] | ELEMENT_MASKS[GROUP_TYPE] |
ELEMENT_MASKS[SEQUENCE_TYPE];
/** Mask bits for attribute child elements. */
private long ATTRIBUTE_MASK = ELEMENT_MASKS[ATTRIBUTE_TYPE] |
ELEMENT_MASKS[ATTRIBUTEGROUP_TYPE];
/** Mask bits for attribute child elements. */
private long ANYATTRIBUTE_MASK = ELEMENT_MASKS[ANYATTRIBUTE_TYPE];
//
// Instance data
/** Filtered list of content type definition (simpleContent or
complexContent, one only and only if no direct content definition). */
private final FilteredSegmentList m_contentTypeList;
/** Filtered list of direct content definition (group reference or
compositor, one only, only if no content type). */
private final FilteredSegmentList m_contentDefinitionList;
/** Filtered list of attribute definitions (only if no content type). */
private final FilteredSegmentList m_attributeList;
/** Filtered list of anyAttribute definitions (zero or one, only if no
content type). */
private final FilteredSegmentList m_anyAttributeList;
/** 'abstract' attribute value. */
private Boolean m_abstract;
/** 'mixed' attribute value. */
private Boolean m_mixed;
/** 'block' attribute value. */
private AllEnumSet m_block;
/** 'final' attribute value. */
private AllEnumSet m_final;
/**
* Constructor.
*/
public ComplexTypeElement() {
super(COMPLEXTYPE_TYPE);
m_contentTypeList = new FilteredSegmentList(getChildrenWritable(),
CONTENT_TYPE_MASK, this);
m_contentDefinitionList = new FilteredSegmentList(getChildrenWritable(),
CONTENT_DEFINITION_MASK, m_contentTypeList, this);
m_attributeList = new FilteredSegmentList(getChildrenWritable(),
ATTRIBUTE_MASK, m_contentDefinitionList, this);
m_anyAttributeList = new FilteredSegmentList(getChildrenWritable(),
ANYATTRIBUTE_MASK, m_attributeList, this);
m_block = new AllEnumSet(ElementElement.s_derivationValues,
"block");
m_final = new AllEnumSet(ElementElement.s_derivationValues,
"final");
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
/* (non-Javadoc)
* @see org.jibx.schema.CommonTypeDefinition#isComplexType()
*/
public boolean isComplexType() {
return true;
}
/* (non-Javadoc)
* @see org.jibx.schema.elements.CommonTypeDefinition#isPredefinedType()
*/
public boolean isPredefinedType() {
return false;
}
//
// Access methods
/**
* Check 'abstract' attribute value.
*
* @return abstract
*/
public boolean isAbstract() {
return m_abstract != null && m_abstract.booleanValue();
}
/**
* Get 'abstract' attribute value.
*
* @return abstract
*/
public Boolean getAbstract() {
return m_abstract;
}
/**
* Set 'abstract' attribute value.
*
* @param abs
*/
public void setAbstract(boolean abs) {
m_abstract = abs ? Boolean.TRUE : Boolean.FALSE;
}
/**
* Check 'mixed' attribute value.
*
* @return mixed
*/
public boolean isMixed() {
return m_mixed != null && m_mixed.booleanValue();
}
/**
* Get 'mixed' attribute value.
*
* @return mixed
*/
public Boolean getMixed() {
return m_mixed;
}
/**
* Set 'mixed' attribute value.
*
* @param mixed
*/
public void setMixed(boolean mixed) {
m_mixed = mixed ? Boolean.TRUE : Boolean.FALSE;
}
/**
* Get 'block' attribute value.
*
* @return block
*/
public AllEnumSet getBlock() {
return m_block;
}
/**
* Get 'final' attribute value.
*
* @return final
*/
public AllEnumSet getFinal() {
return m_final;
}
/**
* Get content type element.
*
* @return content type definition, or null if none
*/
public CommonContentBase getContentType() {
return m_contentTypeList.size() > 0 ?
(CommonContentBase)m_contentTypeList.get(0) : null;
}
/**
* Set content type element.
*
* @param element content type definition, or null if none
*/
public void setContentType(CommonContentBase element) {
m_contentTypeList.clear();
if (element != null) {
m_contentTypeList.add(element);
}
}
/**
* Get content definition particle.
*
* @return content definition particle, or null if none
*/
public CommonCompositorBase getContentDefinition() {
return m_contentDefinitionList.size() > 0 ?
(CommonCompositorBase)m_contentDefinitionList.get(0) : null;
}
/**
* Set content definition particle.
*
* @param element content definition particle, or null if none
*/
public void setContentDefinition(CommonCompositorBase element) {
m_contentDefinitionList.clear();
if (element != null) {
m_contentDefinitionList.add(element);
}
}
/**
* Get list of attribute child elements. This list must be empty when
* a simpleContent or complexContent definition is used.
*
* @return list of attributes
*/
public FilteredSegmentList getAttributeList() {
return m_attributeList;
}
/**
* Get anyAttribute child element.
*
* @return element, or null if none
*/
public AnyAttributeElement getAnyAttribute() {
return m_anyAttributeList.size() > 0 ?
(AnyAttributeElement)m_anyAttributeList.get(0) : null;
}
/**
* Set anyAttribute child element.
*
* @param element element, or null if unsetting
*/
public void setAnyAttribute(AnyAttributeElement element) {
m_anyAttributeList.clear();
if (element != null) {
m_anyAttributeList.add(element);
}
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check whether global or local definition
if (!isGlobal()) {
// make sure local type prohibited attributes are not present
if (getAbstract() != null || getBlock().isPresent() || getFinal().isPresent()) {
vctx.addError("The 'abstract', 'block', and 'final' attributes are prohibited for a local definition", this);
}
}
// check form of definition
if (m_contentTypeList.size() > 0) {
if (m_contentTypeList.size() > 1) {
vctx.addError("Can only have one or child", this);
}
if (m_contentDefinitionList.size() > 0) {
vctx.addError("Child content particles not allowed with or ", this);
}
if (m_attributeList.size() > 0) {
vctx.addError("Child and elements not allowed with or ", this);
}
if (m_anyAttributeList.size() > 0) {
vctx.addError("Child elements not allowed with or ", this);
}
} else if (m_contentDefinitionList.size() > 1) {
vctx.addError("Can only have one /// child", this);
}
if (m_anyAttributeList.size() > 1) {
vctx.addError("Only one child allowed", this);
}
// continue with parent class prevalidation
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/SimpleTypeElement.java 0000644 0001750 0001750 00000012331 11072342064 027172 0 ustar twerner twerner /*
Copyright (c) 2006-2008, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.types.AllEnumSet;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Representation for a simpleType element.
*
* @author Dennis M. Sosnoski
*/
public class SimpleTypeElement extends CommonTypeDefinition
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "final" },
CommonTypeDefinition.s_allowedAttributes);
/** Mask bits for content derivation child elements. */
private long CONTENT_DERIVATION_MASK = ELEMENT_MASKS[LIST_TYPE] |
ELEMENT_MASKS[RESTRICTION_TYPE] | ELEMENT_MASKS[UNION_TYPE];
//
// Value set information
public static final int LIST_FINAL = 0;
public static final int RESTRICTION_FINAL = 1;
public static final int UNION_FINAL = 2;
public static final EnumSet s_simpleDerivationValues = new EnumSet(LIST_FINAL,
new String[] { "list", "restriction", "union"});
//
// Instance data
/** Filtered list of content derivation elements (must be exactly one). */
private final FilteredSegmentList m_contentDerivationList;
/** 'final' attribute value. */
private AllEnumSet m_final;
/**
* Constructor.
*/
public SimpleTypeElement() {
super(SIMPLETYPE_TYPE);
m_contentDerivationList = new FilteredSegmentList(getChildrenWritable(),
CONTENT_DERIVATION_MASK, this);
m_final = new AllEnumSet(s_simpleDerivationValues, "final");
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
/* (non-Javadoc)
* @see org.jibx.schema.CommonTypeDefinition#isComplexType()
*/
public boolean isComplexType() {
return false;
}
/* (non-Javadoc)
* @see org.jibx.schema.elements.CommonTypeDefinition#isPredefinedType()
*/
public boolean isPredefinedType() {
return false;
}
//
// Access methods
/**
* Get 'final' attribute value.
*
* @return final
*/
public AllEnumSet getFinal() {
return m_final;
}
/**
* Get derivation child element.
*
* @return derivation element, or null if not yet set
*/
public SchemaBase getDerivation() {
return m_contentDerivationList.size() > 0 ?
(SchemaBase)m_contentDerivationList.get(0) : null;
}
/**
* Set derivation child element.
*
* @param element derivation element, or null if unsetting
*/
public void setDerivation(SchemaBase element) {
m_contentDerivationList.clear();
if (element != null) {
m_contentDerivationList.add(element);
}
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check whether global or local definition
if (!isGlobal()) {
// make sure local type prohibited attributes are not present
if (getFinal().isPresent()) {
vctx.addError("The 'final' attribute is prohibited for a local definition", this);
}
}
// continue with parent class prevalidation
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/CommonSimpleModification.java 0000644 0001750 0001750 00000011647 11145001362 030520 0 ustar twerner twerner /*
Copyright (c) 2006-2009, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.validation.ValidationContext;
/**
* Base representation for all simple type modification elements. This includes
* both extension and restriction, but only when used with simple
* types.
*
* @author Dennis M. Sosnoski
*/
public class CommonSimpleModification extends CommonTypeDerivation
{
/** Mask bits for attribute child elements. */
private long ATTRIBUTE_MASK = ELEMENT_MASKS[ATTRIBUTE_TYPE] |
ELEMENT_MASKS[ATTRIBUTEGROUP_TYPE];
/** Mask bits for attribute child elements. */
private long ANYATTRIBUTE_MASK = ELEMENT_MASKS[ANYATTRIBUTE_TYPE];
//
// Instance data
/** Filtered list of attribute definitions. */
private final FilteredSegmentList m_attributeList;
/** Filtered list of anyAttribute definitions (zero or one). */
private final FilteredSegmentList m_anyAttributeList;
/**
* Constructor.
*
* @param type actual element type
*/
public CommonSimpleModification(int type) {
super(type);
m_attributeList = new FilteredSegmentList(getChildrenWritable(),
ATTRIBUTE_MASK, this);
m_anyAttributeList = new FilteredSegmentList(getChildrenWritable(),
ANYATTRIBUTE_MASK, m_attributeList, this);
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.elements.CommonTypeDerivation#isComplexType()
*/
public boolean isComplexType() {
return false;
}
/* (non-Javadoc)
* @see org.jibx.schema.elements.CommonTypeDerivation#isExtension()
*/
public boolean isExtension() {
return true;
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Access methods
/**
* Get list of attribute child elements. This list must be empty when
* a simpleContent or complexContent definition is used.
*
* @return list of attributes
*/
public FilteredSegmentList getAttributeList() {
return m_attributeList;
}
/**
* Get anyAttribute child element.
*
* @return element, or null if none
*/
public AnyAttributeElement getAnyAttribute() {
return m_anyAttributeList.size() > 0 ?
(AnyAttributeElement)m_anyAttributeList.get(0) : null;
}
/**
* Set anyAttribute child element.
*
* @param element element, or null if unsetting
*/
public void setAnyAttribute(AnyAttributeElement element) {
m_anyAttributeList.clear();
if (element != null) {
m_anyAttributeList.add(element);
}
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check form of definition
if (m_anyAttributeList.size() > 1) {
vctx.addError("Only one child allowed", this);
}
// continue with parent class prevalidation
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/GroupElement.java 0000644 0001750 0001750 00000012157 11062041170 026172 0 ustar twerner twerner /*
Copyright (c) 2006-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.schema.INamed;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Top-level group element definition.
*
* @author Dennis M. Sosnoski
*/
public class GroupElement extends AnnotatedBase implements INamed
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "name" },
AnnotatedBase.s_allowedAttributes);
/** Mask bits for allowed child elements. */
private long DEFINITION_MASK = ELEMENT_MASKS[ALL_TYPE] |
ELEMENT_MASKS[CHOICE_TYPE] | ELEMENT_MASKS[SEQUENCE_TYPE];
//
// Instance data
/** Filtered list of composited particle elements. */
private final FilteredSegmentList m_definitionList;
/** 'name' attribute value. */
private String m_name;
/** Qualified name (only defined after validation). */
private QName m_qname;
/**
* Constructor.
*/
public GroupElement() {
super(GROUP_TYPE);
m_definitionList = new FilteredSegmentList(getChildrenWritable(),
DEFINITION_MASK, this);
}
//
// Access methods
/**
* Get 'name' attribute value.
*
* @return name
*/
public String getName() {
return m_name;
}
/**
* Set 'name' attribute value.
*
* @param name
*/
public void setName(String name) {
m_name = name;
}
/**
* Get qualified name for element. This method is only usable after
* prevalidation.
*
* @return qname (null if not defined)
*/
public QName getQName() {
return m_qname;
}
/**
* Get definition element.
*
* @return definition element, or null if not set
*/
public CommonCompositorDefinition getDefinition() {
return m_definitionList.size() > 0 ?
(CommonCompositorDefinition)m_definitionList.get(0) : null;
}
/**
* Set definition element.
*
* @param element definition element, or null if unsetting
*/
public void setDefinition(CommonCompositorDefinition element) {
m_definitionList.clear();
if (element != null) {
m_definitionList.add(element);
}
}
//
// Overrides of base class methods
/* (non-Javadoc)
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check for missing items
if (m_name == null) {
vctx.addError("Missing required 'name' attribute", this);
} else {
m_qname = new QName(vctx.getCurrentSchema().getEffectiveNamespace(),
getName());
}
if (m_definitionList.size() == 0) {
vctx.addError("Missing required , , or child element", this);
} else if (m_definitionList.size() > 1) {
vctx.addError("Only one , , or child element allowed", this);
}
// continue with parent class prevalidation
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/GroupRefElement.java 0000644 0001750 0001750 00000010635 11167465000 026636 0 ustar twerner twerner /*
Copyright (c) 2006-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.schema.IReference;
import org.jibx.schema.support.QNameConverter;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Definition for embedded group element (group reference).
*
* @author Dennis M. Sosnoski
*/
public class GroupRefElement extends CommonCompositorBase implements IReference
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "ref" },
CommonCompositorBase.s_allowedAttributes);
//
// Instance data
/** Reference definition. */
private QName m_ref;
/** Referenced element (filled in by validation). */
private GroupElement m_refGroup;
/**
* Constructor.
*/
public GroupRefElement() {
super(GROUP_TYPE);
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Access methods
/**
* Get 'ref' attribute value.
*
* @return ref
*/
public QName getRef() {
return m_ref;
}
/**
* Set 'ref' attribute value.
*
* @param ref
*/
public void setRef(QName ref) {
m_ref = ref;
}
/**
* Get the referenced group declaration. This method is only usable after
* validation.
*
* @return referenced group definition
*/
public GroupElement getReference() {
return m_refGroup;
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
if (m_ref == null) {
vctx.addFatal("'ref' attribute is required for group reference", this);
} else {
// patch qualified name with schema effective namespace
SchemaElement schema = vctx.getCurrentSchema();
String ens = schema.getEffectiveNamespace();
QNameConverter.patchQNameNamespace(ens, m_ref);
}
}
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#validate(org.jibx.schema.ValidationContext)
*/
public void validate(ValidationContext vctx) {
// make sure element reference is defined
m_refGroup = vctx.findGroup(m_ref);
if (m_refGroup == null) {
vctx.addFatal("Referenced group '" + m_ref + "' is not defined", this);
}
// handle base class validation
super.validate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/ElementElement.java 0000644 0001750 0001750 00000046165 11366034146 026511 0 ustar twerner twerner /*
* Copyright (c) 2006-2010, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.schema.IArity;
import org.jibx.schema.INamed;
import org.jibx.schema.IReference;
import org.jibx.schema.attributes.DefRefAttributeGroup;
import org.jibx.schema.attributes.FormChoiceAttribute;
import org.jibx.schema.attributes.OccursAttributeGroup;
import org.jibx.schema.support.QNameConverter;
import org.jibx.schema.types.AllEnumSet;
import org.jibx.schema.types.Count;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* <element> element definition. The same code is used for both global and local element definitions, with the
* differences checked during validation.
*
* TODO: implement common base class for attribute and element?
*
* @author Dennis M. Sosnoski
*/
public class ElementElement extends AnnotatedBase implements IArity, INamed, IReference
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes = new StringArray(new String[] { "abstract", "block",
"default", "final", "fixed", "nillable", "substitutionGroup", "type" },
DefRefAttributeGroup.s_allowedAttributes, FormChoiceAttribute.s_allowedAttributes,
OccursAttributeGroup.s_allowedAttributes, AnnotatedBase.s_allowedAttributes);
/** Mask bits for inline type definition child. */
private long INLINE_TYPE_MASK = ELEMENT_MASKS[COMPLEXTYPE_TYPE] | ELEMENT_MASKS[SIMPLETYPE_TYPE];
/** Mask bits for identity constraint children. */
private long IDENTITY_CONSTRAINT_MASK = ELEMENT_MASKS[KEY_TYPE] | ELEMENT_MASKS[KEYREF_TYPE] |
ELEMENT_MASKS[UNIQUE_TYPE];
//
// Value set information
public static final int EXTENSION_BLOCK = 0;
public static final int RESTRICTION_BLOCK = 1;
public static final int SUBSTITUTION_BLOCK = 2;
public static final EnumSet s_blockValues = new EnumSet(EXTENSION_BLOCK, new String[] { "extension", "restriction",
"substitution" });
public static final int EXTENSION_FINAL = 0;
public static final int RESTRICTION_FINAL = 1;
public static final EnumSet s_derivationValues = new EnumSet(EXTENSION_FINAL, new String[] { "extension",
"restriction" });
//
// Instance data
/** Filtered list of inline type definition elements (zero or one only). */
private final FilteredSegmentList m_inlineTypeList;
/** Filtered list of identity constraint elements (zero or more). */
private final FilteredSegmentList m_identityConstraintList;
/** Name or reference. */
private DefRefAttributeGroup m_defRef;
/** Form of name. */
private FormChoiceAttribute m_formChoice;
/** Occurs attribute group. */
private OccursAttributeGroup m_occurs;
/** 'type' attribute value. */
private QName m_type;
/** 'default' attribute value. */
private String m_default;
/** 'fixed' attribute value. */
private String m_fixed;
/** 'abstract' attribute value. */
private boolean m_abstract;
/** 'nillable' attribute value. */
private boolean m_nillable;
/** 'block' attribute value. */
private AllEnumSet m_block;
/** 'final' attribute value. */
private AllEnumSet m_final;
/** 'substitutionGroup' attribute information. */
private QName m_substitutionGroup;
/** Element definition (from 'ref' attribute - null if none). */
private ElementElement m_refElement;
/**
* Complex or simple type definition (from 'type' attribute, or inline definition - null if none).
*/
private CommonTypeDefinition m_typeDefinition;
/** Qualified name (only defined after validation). */
private QName m_qname;
/**
* Constructor.
*/
public ElementElement() {
super(ELEMENT_TYPE);
m_inlineTypeList = new FilteredSegmentList(getChildrenWritable(), INLINE_TYPE_MASK, this);
m_identityConstraintList = new FilteredSegmentList(getChildrenWritable(), IDENTITY_CONSTRAINT_MASK,
m_inlineTypeList, this);
m_defRef = new DefRefAttributeGroup(this);
m_formChoice = new FormChoiceAttribute(this);
m_occurs = new OccursAttributeGroup(this);
m_block = new AllEnumSet(s_blockValues, "block");
m_final = new AllEnumSet(s_derivationValues, "final");
}
/**
* Clear any type information. This method is only visible for internal use, to be called in the process of setting
* new type information.
*/
private void clearType() {
m_inlineTypeList.clear();
m_defRef.setRef(null);
m_refElement = null;
m_type = null;
m_typeDefinition = null;
}
//
// Base class overrides
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Access methods
/**
* Get 'type' attribute value.
*
* @return type (null if not set)
*/
public QName getType() {
return m_type;
}
/**
* Set 'type' attribute value. Note that this method should only be used prior to validation, since it will only set
* the type name and not link the actual type information.
*
* @param type (null if not set)
*/
public void setType(QName type) {
clearType();
m_type = type;
}
/**
* Get 'default' attribute value.
*
* @return default (null if not set)
*/
public String getDefault() {
return m_default;
}
/**
* Set the 'default' attribute value.
*
* @param dflt (null if not set)
*/
public void setDefault(String dflt) {
m_default = dflt;
}
/**
* Get 'fixed' attribute value.
*
* @return fixed (null if not set)
*/
public String getFixed() {
return m_fixed;
}
/**
* Set 'fixed' attribute value.
*
* @param fixed (null if not set)
*/
public void setFixed(String fixed) {
m_fixed = fixed;
}
/**
* Check 'abstract' attribute value.
*
* @return abstract attribute value
*/
public boolean isAbstract() {
return m_abstract;
}
/**
* Set 'abstract' attribute value.
*
* @param abs abstract attribute value
*/
public void setAbstract(boolean abs) {
m_abstract = abs;
}
/**
* Check 'nillable' attribute value.
*
* @return nillable attribute value (null if not set)
*/
public boolean isNillable() {
return m_nillable;
}
/**
* Set 'nillable' attribute value.
*
* @param nil nillable attribute value (null if not set)
*/
public void setNillable(boolean nil) {
m_nillable = nil;
}
/**
* Get 'final' attribute.
*
* @return final
*/
public AllEnumSet getFinal() {
return m_final;
}
/**
* Get 'block' attribute.
*
* @return block
*/
public AllEnumSet getBlock() {
return m_block;
}
/**
* Get 'substitutionGroup' attribute value.
*
* @return substitutionGroup (null if not set)
*/
public QName getSubstitutionGroup() {
return m_substitutionGroup;
}
/**
* Set 'substitutionGroup' attribute value.
*
* @param qname (null if not set)
*/
public void setSubstitutionGroup(QName qname) {
m_substitutionGroup = qname;
}
/**
* Get the referenced element declaration. This method is only usable after validation.
*
* @return referenced element definition, or null if not a reference
*/
public ElementElement getReference() {
return m_refElement;
}
/**
* Get qualified name set directly on element. This method is only usable
* after prevalidation.
*
* @return qname (null if a reference)
*/
public QName getQName() {
return m_qname;
}
/**
* Get effective qualified name for element (whether defined directly, or by
* reference). This method is only usable after prevalidation.
*
* @return qname
*/
public QName getEffectiveQName() {
if (m_qname == null) {
return m_defRef.getRef();
} else {
return m_qname;
}
}
/**
* Check if the element uses an inline type definition.
*
* @return true if inline, false if not
*/
public boolean isInlineType() {
return m_inlineTypeList.size() == 1;
}
/**
* Get type definition. This returns the actual type definition for the element, irrespective of whether the element
* uses an element reference, a type reference, or an inline type definition. It is only usable after validation.
*
* @return type definition (null if empty type definition)
*/
public CommonTypeDefinition getTypeDefinition() {
if (m_defRef.getRef() != null) {
return m_refElement.getTypeDefinition();
} else {
return m_typeDefinition;
}
}
/**
* Set type definition (either inline, or as reference).
*
* @param def inline type definition
*/
public void setTypeDefinition(CommonTypeDefinition def) {
// clear existing type information and set new
clearType();
m_typeDefinition = def;
// check form of type definition
if (def != null) {
if (def.getQName() == null) {
// embed inline type definition
m_inlineTypeList.add(def);
def.setParent(this);
} else {
// set type reference
m_type = def.getQName();
}
}
}
/**
* Get list of identity constraint child elements.
*
* @return list
*/
public FilteredSegmentList getIdentityConstraintList() {
return m_identityConstraintList;
}
//
// Delegated methods
/**
* Get 'name' attribute value.
*
* @return name
* @see org.jibx.schema.attributes.DefRefAttributeGroup#getName()
*/
public String getName() {
return m_defRef.getName();
}
/**
* Get 'ref' attribute value.
*
* @return ref
* @see org.jibx.schema.attributes.DefRefAttributeGroup#getRef()
*/
public QName getRef() {
return m_defRef.getRef();
}
/**
* Set 'name' attribute value.
*
* @param name
* @see org.jibx.schema.attributes.DefRefAttributeGroup#setName(java.lang.String)
*/
public void setName(String name) {
m_defRef.setName(name);
}
/**
* Set 'ref' attribute value.
*
* @param ref
* @see org.jibx.schema.attributes.DefRefAttributeGroup#setRef(org.jibx.runtime.QName)
*/
public void setRef(QName ref) {
clearType();
m_defRef.setRef(ref);
}
/**
* Get 'form' attribute type code.
*
* @return form
* @see org.jibx.schema.attributes.FormChoiceAttribute#getForm()
*/
public int getForm() {
return m_formChoice.getForm();
}
/**
* Get 'form' attribute name value.
*
* @return form
* @see org.jibx.schema.attributes.FormChoiceAttribute#getFormText()
*/
public String getFormText() {
return m_formChoice.getFormText();
}
/**
* Set 'form' attribute type code.
*
* @param type
* @see org.jibx.schema.attributes.FormChoiceAttribute#setForm(int)
*/
public void setForm(int type) {
m_formChoice.setForm(type);
}
/**
* Get 'maxOccurs' attribute value.
*
* @return count
* @see org.jibx.schema.attributes.OccursAttributeGroup#getMaxOccurs()
*/
public Count getMaxOccurs() {
return m_occurs.getMaxOccurs();
}
/**
* Get 'minOccurs' attribute value.
*
* @return count
* @see org.jibx.schema.attributes.OccursAttributeGroup#getMinOccurs()
*/
public Count getMinOccurs() {
return m_occurs.getMinOccurs();
}
/**
* Set 'maxOccurs' attribute value.
*
* @param count
* @see org.jibx.schema.attributes.OccursAttributeGroup#setMaxOccurs(org.jibx.schema.types.Count)
*/
public void setMaxOccurs(Count count) {
m_occurs.setMaxOccurs(count);
}
/**
* Get 'maxOccurs' attribute value.
*
* @param count
* @see org.jibx.schema.attributes.OccursAttributeGroup#setMinOccurs(org.jibx.schema.types.Count)
*/
public void setMinOccurs(Count count) {
m_occurs.setMinOccurs(count);
}
//
// Validation methods
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// prevalidate the attributes
m_defRef.prevalidate(vctx);
m_formChoice.prevalidate(vctx);
m_occurs.prevalidate(vctx);
// patch qualified names with schema effective namespace
SchemaElement schema = vctx.getCurrentSchema();
String ens = schema.getEffectiveNamespace();
QNameConverter.patchQNameNamespace(ens, m_substitutionGroup);
QNameConverter.patchQNameNamespace(ens, m_type);
// check whether global or local definition
if (isGlobal()) {
// make sure name is supplied for global element
if (getName() == null) {
vctx.addError("The 'name' attribute is required for a global definition", this);
} else {
m_qname = new QName(ens, getName());
}
// make sure prohibited attributes are not present
if (getRef() != null || getForm() != -1 || getMinOccurs() != null || getMaxOccurs() != null) {
vctx.addError("The 'ref', 'form', 'minOccurs' and 'maxOccurs' attributes are prohibited for a global element definition", this);
}
} else {
// make sure name or reference is supplied for local element
if (getName() == null && getRef() == null) {
vctx.addError(
"Either a 'name' attribute or a 'ref' attribute is required for a local element definition", this);
}
// generate qname if name supplied
if (getName() != null) {
boolean def = schema.isElementQualifiedDefault();
String uri = null;
if (m_formChoice.isQualified(def)) {
uri = ens;
}
m_qname = new QName(uri, getName());
}
// make sure prohibited attributes are not present
if (getSubstitutionGroup() != null || getBlock().isPresent() || getFinal().isPresent()) {
vctx.addError("The 'substitutionGroup', 'block', and 'final' attributes are prohibited for a local element definition", this);
}
}
// continue with parent class prevalidation
super.prevalidate(vctx);
}
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ComponentBase#validate(org.jibx.schema.ValidationContext)
*/
public void validate(ValidationContext vctx) {
// start with validating the attributes
m_defRef.validate(vctx);
m_formChoice.validate(vctx);
// check type of definition
QName ref = getRef();
if (ref != null) {
// make sure element reference is defined
m_refElement = vctx.findElement(ref);
if (m_refElement == null) {
vctx.addFatal("Referenced element '" + ref + "' is not defined", this);
}
// check for any conflicting attributes
if (m_type != null) {
vctx.addError("'type' attribute not allowed with 'ref' attribute", this);
}
} else {
// set the type definition
if (m_type == null) {
// verify inline type definition
if (m_inlineTypeList.size() == 1) {
m_typeDefinition = (CommonTypeDefinition)m_inlineTypeList.get(0);
} else if (m_inlineTypeList.size() == 0) {
vctx.addWarning("No type defined", this);
} else {
vctx.addFatal("Only one inline type definition allowed", this);
}
} else {
// look up referenced type definition
m_typeDefinition = vctx.findType(m_type);
if (m_typeDefinition == null) {
vctx.addFatal("Referenced type '" + m_type + "' is not defined", this);
}
}
}
// handle base class validation if still going
if (!vctx.isSkipped(this)) {
super.validate(vctx);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/SimpleContentElement.java 0000644 0001750 0001750 00000004520 10602646266 027675 0 ustar twerner twerner /*
Copyright (c) 2006, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
/**
* Representation for a simpleContent element.
*
* @author Dennis M. Sosnoski
*/
public class SimpleContentElement extends CommonContentBase
{
/**
* Constructor.
*/
public SimpleContentElement() {
super(SIMPLECONTENT_TYPE);
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.elements.CommonContentBase#isComplexContent()
*/
public boolean isComplexContent() {
return false;
}
/* (non-Javadoc)
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/SimpleExtensionElement.java 0000644 0001750 0001750 00000003736 11145001362 030230 0 ustar twerner twerner /*
Copyright (c) 2009, Dennis M. Sosnoski. 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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
/**
* Definition for extension element used with a simple type.
*
* @author Dennis M. Sosnoski
*/
public class SimpleExtensionElement extends CommonSimpleModification
{
/**
* Constructor.
*/
public SimpleExtensionElement() {
super(EXTENSION_TYPE);
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.elements.CommonTypeDerivation#isExtension()
*/
public boolean isExtension() {
return true;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/AnyElement.java 0000644 0001750 0001750 00000011020 11126622130 025613 0 ustar twerner twerner /*
* Copyright (c) 2006-2008, Dennis M. Sosnoski 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. Neither the name of JiBX nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.IArity;
import org.jibx.schema.attributes.OccursAttributeGroup;
import org.jibx.schema.types.Count;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* anyAttribute element definition.
*
* @author Dennis M. Sosnoski
*/
public class AnyElement extends WildcardBase implements IArity
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes =
new StringArray(WildcardBase.s_allowedAttributes,
OccursAttributeGroup.s_allowedAttributes);
//
// Instance data
/** Occurs attribute group. */
private OccursAttributeGroup m_occurs;
/**
* Constructor.
*/
public AnyElement() {
super(ANY_TYPE);
m_occurs = new OccursAttributeGroup(this);
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Delegated methods
/**
* Get 'maxOccurs' attribute value.
*
* @return count
* @see org.jibx.schema.attributes.OccursAttributeGroup#getMaxOccurs()
*/
public Count getMaxOccurs() {
return m_occurs.getMaxOccurs();
}
/**
* Get 'minOccurs' attribute value.
*
* @return count
* @see org.jibx.schema.attributes.OccursAttributeGroup#getMinOccurs()
*/
public Count getMinOccurs() {
return m_occurs.getMinOccurs();
}
/**
* Set 'maxOccurs' attribute value.
*
* @param count
* @see org.jibx.schema.attributes.OccursAttributeGroup#setMaxOccurs(org.jibx.schema.types.Count)
*/
public void setMaxOccurs(Count count) {
m_occurs.setMaxOccurs(count);
}
/**
* Get 'maxOccurs' attribute value.
*
* @param count
* @see org.jibx.schema.attributes.OccursAttributeGroup#setMinOccurs(org.jibx.schema.types.Count)
*/
public void setMinOccurs(Count count) {
m_occurs.setMinOccurs(count);
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// prevalidate the attributes
m_occurs.prevalidate(vctx);
// continue with parent class prevalidation
super.prevalidate(vctx);
}
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#validate(org.jibx.schema.ValidationContext)
*/
public void validate(ValidationContext vctx) {
// validate the attributes
m_occurs.validate(vctx);
// handle base class validation
super.validate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/SequenceElement.java 0000644 0001750 0001750 00000003517 10624256130 026655 0 ustar twerner twerner /*
Copyright (c) 2006-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
/**
* <sequence> element definition. This is just a trivial variation of the
* base compositor class.
*
* @author Dennis M. Sosnoski
*/
public class SequenceElement extends CommonCompositorDefinition
{
/**
* Constructor.
*/
public SequenceElement() {
super(SEQUENCE_TYPE, CHOICE_SEQUENCE_PARTICLE_MASK);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/ImportElement.java 0000644 0001750 0001750 00000011252 11252237150 026351 0 ustar twerner twerner /*
Copyright (c) 2006-2008, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import java.io.IOException;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.ISchemaResolver;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Model component for import element.
*
* @author Dennis M. Sosnoski
*/
public class ImportElement extends SchemaLocationBase
{
/** Enumeration of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "namespace" },
SchemaLocationBase.s_allowedAttributes);
/** 'namespace' attribute value. */
private String m_namespace;
/**
* Constructor.
*/
public ImportElement() {
super(IMPORT_TYPE);
}
//
// Access methods
public String getNamespace() {
return m_namespace;
}
public void setNamespace(String namespace) {
m_namespace = namespace;
}
//
// Base class overrides
protected String getEffectiveNamespace() {
return null;
}
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Base class overrides
/**
* Prevalidation handling. This loads and sets the referenced schema, using
* either the 'namespace' or 'schemaLocation' attribute, or both.
*
* @param vctx validation context
*/
public void prevalidate(ValidationContext vctx) {
String location = getLocation();
if (location == null) {
if (m_namespace == null) {
// no way to find the referenced schema
vctx.addFatal("Either 'namespace' or 'schemaLocation' value required", this);
} else {
// find schema based on namespace (must already be known)
SchemaElement schema = vctx.getSchemaById(m_namespace);
if (schema == null) {
vctx.addFatal("No known schema for namespace " + m_namespace, this);
} else {
setReferencedSchema(schema);
}
}
} else {
try {
// find or load referenced schema
SchemaElement curschema = vctx.getCurrentSchema();
ISchemaResolver resolver =
curschema.getResolver().resolve(location, m_namespace);
SchemaElement schema = vctx.getSchemaById(resolver.getId());
if (schema == null) {
schema = readSchema(vctx, resolver);
vctx.setSchema(resolver.getId(), schema);
schema.setResolver(resolver);
}
setReferencedSchema(schema);
} catch (JiBXException e) {
vctx.addFatal("Error loading schema: " + e.getMessage(), this);
} catch (IOException e) {
vctx.addFatal("Error loading schema: " + e.getMessage(), this);
}
}
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/DocumentationElement.java 0000644 0001750 0001750 00000004132 11155044604 027711 0 ustar twerner twerner /*
Copyright (c) 2006-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
/**
* documentation annotation item element.
*/
public class DocumentationElement extends AnnotationItem
{
/** xml:lang attribute value. */
private String m_xmlLang;
/**
* Constructor.
*/
public DocumentationElement() {
super(DOCUMENTATION_TYPE);
}
/**
* Get language code.
*
* @return language code
*/
public String getXmlLang() {
return m_xmlLang;
}
/**
* Set language code.
*
* @param xmlLang xmlLang
*/
public void setXmlLang(String xmlLang) {
m_xmlLang = xmlLang;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/CommonTypeDefinition.java 0000644 0001750 0001750 00000010340 11167465000 027667 0 ustar twerner twerner /*
Copyright (c) 2006-2008, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.QName;
import org.jibx.schema.INamed;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Base representation for all type definition elements.
*
* @author Dennis M. Sosnoski
*/
public abstract class CommonTypeDefinition extends AnnotatedBase implements INamed
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "name" },
AnnotatedBase.s_allowedAttributes);
/** 'name' attribute value. */
private String m_name;
/** Qualified name. */
protected QName m_qname;
/**
* Constructor.
*
* @param type actual element type
*/
public CommonTypeDefinition(int type) {
super(type);
}
/**
* Check if a complex type definition.
*
* @return true if complex type, false if simple
* type
*/
public abstract boolean isComplexType();
/**
* Check if a predefined type definition.
*
* @return true if predefined, false if user type
*/
public abstract boolean isPredefinedType();
/**
* Get 'name' attribute value.
*
* @return name
*/
public String getName() {
return m_name;
}
/**
* Set 'name' attribute value.
*
* @param name
*/
public void setName(String name) {
m_name = name;
}
/**
* Get qualified name for type. This method is only usable after validation.
*
* @return qname (null if not defined)
*/
public QName getQName() {
return m_qname;
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check whether global or local definition
if (isGlobal()) {
// make sure name is supplied for global complex type
if (getName() == null) {
vctx.addError("The 'name' attribute is required for a global definition", this);
} else {
String ens = vctx.getCurrentSchema().getEffectiveNamespace();
m_qname = new QName(ens, getName());
}
} else {
// make sure local type prohibited name attribute is not present
if (getName() != null) {
vctx.addError("The 'name' attribute is prohibited for a local definition", this);
}
}
// continue with parent class prevalidation
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/FacetElement.java 0000644 0001750 0001750 00000040014 11072341746 026126 0 ustar twerner twerner /*
* Copyright (c) 2006-2008, Dennis M. Sosnoski 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.EnumSet;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Facet implementation. This base class is used for all facets, with static inner subclasses for the actual facets.
*
* @author Dennis M. Sosnoski
*/
public abstract class FacetElement extends AnnotatedBase
{
//
// Facet bit masks
public static final int LENGTH_FACET_BIT = 0x0001;
public static final int MINLENGTH_FACET_BIT = 0x0002;
public static final int MAXLENGTH_FACET_BIT = 0x0004;
public static final int PATTERN_FACET_BIT = 0x0008;
public static final int ENUMERATION_FACET_BIT = 0x0010;
public static final int WHITESPACE_FACET_BIT = 0x0020;
public static final int MAXINCLUSIVE_FACET_BIT = 0x0040;
public static final int MAXEXCLUSIVE_FACET_BIT = 0x0080;
public static final int MININCLUSIVE_FACET_BIT = 0x0100;
public static final int MINEXCLUSIVE_FACET_BIT = 0x0200;
public static final int TOTALDIGITS_FACET_BIT = 0x0400;
public static final int FRACTIONDIGITS_FACET_BIT = 0x0800;
//
// Facet element tables
/** Ordered array of indexes for facet elements. */
public static final int[] FACET_ELEMENT_INDEXES = { ENUMERATION_TYPE, FRACTIONDIGITS_TYPE, LENGTH_TYPE,
MAXEXCLUSIVE_TYPE, MAXINCLUSIVE_TYPE, MAXLENGTH_TYPE, MINEXCLUSIVE_TYPE, MININCLUSIVE_TYPE, MINLENGTH_TYPE,
PATTERN_TYPE, TOTALDIGITS_TYPE, WHITESPACE_TYPE };
/** Ordered array of names of just the facet elements. */
public static final String[] FACET_ELEMENT_NAMES;
/** Mask for facet elements. */
public static final long FACET_ELEMENT_MASK;
static {
String[] names = new String[FACET_ELEMENT_INDEXES.length];
long mask = 0;
for (int i = 0; i < FACET_ELEMENT_INDEXES.length; i++) {
int index = FACET_ELEMENT_INDEXES[i];
names[i] = ELEMENT_NAMES[index];
mask |= ELEMENT_MASKS[index];
}
FACET_ELEMENT_NAMES = names;
FACET_ELEMENT_MASK = mask;
};
//
// Instance data
/** Facet bit mask. */
private final int m_bitMask;
/** Facet exclusion mask. */
private final int m_excludesMask;
/**
* Constructor.
*
* @param type
* @param bit mask
* @param exclude exclusion bit mask
*/
protected FacetElement(int type, int bit, int exclude) {
super(type);
m_bitMask = bit;
m_excludesMask = exclude;
}
/**
* Get facet bit mask.
*
* @return bit mask
*/
public int getBitMask() {
return m_bitMask;
}
/**
* Get excludes bit mask.
*
* @return bit mask
*/
public int getExcludesMask() {
return m_excludesMask;
}
//
// Actual facet subclasses
public abstract static class FixedFacet extends FacetElement
{
/** List of allowed attribute names (including "id" from base). */
public static final StringArray s_allowedAttributes = new StringArray(new String[] { "fixed", "value" },
AnnotatedBase.s_allowedAttributes);
//
// Instance data
/** "fixed" attribute value. */
private Boolean m_fixed;
/**
* Constructor. Just passes on the element type to base class.
*
* @param type
* @param bit mask
* @param exclude exclusion bit mask
*/
public FixedFacet(int type, int bit, int exclude) {
super(type, bit, exclude);
}
/**
* Check if fixed. This convenience method just returns the default if the attribute value has not been set.
*
* @return true if fixed, false if not
*/
public boolean isFixed() {
return m_fixed == null ? false : m_fixed.booleanValue();
}
/**
* Get "fixed" attribute value.
*
* @return fixed attribute value (null if not set)
*/
public Boolean getFixed() {
return m_fixed;
}
/**
* Set "fixed" attribute value.
*
* @param fixed fixed attribute value (null if unsetting)
*/
public void setFinal(Boolean fixed) {
m_fixed = fixed;
}
//
// Validation methods
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
* @exception JiBXException on unmarshalling error
*/
protected void preset(IUnmarshallingContext uctx) throws JiBXException {
validateAttributes(uctx, s_allowedAttributes);
super.preset(uctx);
}
}
public abstract static class NumFacet extends FixedFacet
{
/** "value" attribute value. */
private int m_value;
/**
* Constructor. Just passes on the element type to base class.
*
* @param type
* @param bit mask
* @param exclude exclusion bit mask
*/
public NumFacet(int type, int bit, int exclude) {
super(type, bit, exclude);
}
/**
* Get "value" attribute value.
*
* @return value attribute value
*/
public int getValue() {
return m_value;
}
/**
* Set "value" attribute value.
*
* @param value value attribute value
*/
public void setValue(int value) {
m_value = value;
}
//
// Validation methods
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check for valid attribute values
if (m_value < 0) {
vctx.addError("'value' attribute must not be negative", this);
}
// continue with parent class prevalidation
super.prevalidate(vctx);
}
}
public static class TotalDigits extends FixedFacet
{
/** "value" attribute value. */
private int m_value;
/**
* Constructor.
*/
public TotalDigits() {
super(TOTALDIGITS_TYPE, TOTALDIGITS_FACET_BIT, TOTALDIGITS_FACET_BIT);
}
/**
* Get "value" attribute value.
*
* @return value attribute value
*/
public int getValue() {
return m_value;
}
/**
* Set "value" attribute value.
*
* @param value value attribute value
*/
public void setValue(int value) {
m_value = value;
}
//
// Validation methods
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check for valid attribute values
if (m_value <= 0) {
vctx.addError("'value' attribute must be strictly positive", this);
}
// continue with parent class prevalidation
super.prevalidate(vctx);
}
}
public static class FractionDigits extends NumFacet
{
/**
* Constructor. Just sets element type in base class.
*/
public FractionDigits() {
super(FRACTIONDIGITS_TYPE, FRACTIONDIGITS_FACET_BIT, FRACTIONDIGITS_FACET_BIT);
}
}
public static class Length extends NumFacet
{
/**
* Constructor. Just sets element type in base class.
*/
public Length() {
super(LENGTH_TYPE, LENGTH_FACET_BIT, LENGTH_FACET_BIT | MINLENGTH_FACET_BIT | MAXLENGTH_FACET_BIT);
}
}
public static class MinLength extends NumFacet
{
/**
* Constructor. Just sets element type in base class.
*/
public MinLength() {
super(MINLENGTH_TYPE, MINLENGTH_FACET_BIT, LENGTH_FACET_BIT | MINLENGTH_FACET_BIT);
}
}
public static class MaxLength extends NumFacet
{
/**
* Constructor. Just sets element type in base class.
*/
public MaxLength() {
super(MAXLENGTH_TYPE, MAXLENGTH_FACET_BIT, LENGTH_FACET_BIT | MAXLENGTH_FACET_BIT);
}
}
public abstract static class TextFacet extends FixedFacet
{
/** "value" attribute value. */
private String m_value;
/**
* Constructor. Just passes on the element type to base class.
*
* @param type
* @param bit mask
* @param exclude exclusion bit mask
*/
public TextFacet(int type, int bit, int exclude) {
super(type, bit, exclude);
}
/**
* Get "value" attribute value.
*
* @return value attribute value
*/
public String getValue() {
return m_value;
}
/**
* Set "value" attribute value.
*
* @param value value attribute value
*/
public void setValue(String value) {
m_value = value;
}
}
public static class MinExclusive extends TextFacet
{
/**
* Constructor. Just sets element type in base class.
*/
public MinExclusive() {
super(MINEXCLUSIVE_TYPE, MINEXCLUSIVE_FACET_BIT, MINEXCLUSIVE_FACET_BIT | MININCLUSIVE_FACET_BIT);
}
}
public static class MinInclusive extends TextFacet
{
/**
* Constructor. Just sets element type in base class.
*/
public MinInclusive() {
super(MININCLUSIVE_TYPE, MININCLUSIVE_FACET_BIT, MINEXCLUSIVE_FACET_BIT | MININCLUSIVE_FACET_BIT);
}
}
public static class MaxExclusive extends TextFacet
{
/**
* Constructor. Just sets element type in base class.
*/
public MaxExclusive() {
super(MAXEXCLUSIVE_TYPE, MAXEXCLUSIVE_FACET_BIT, MAXEXCLUSIVE_FACET_BIT | MAXINCLUSIVE_FACET_BIT);
}
}
public static class MaxInclusive extends TextFacet
{
/**
* Constructor. Just sets element type in base class.
*/
public MaxInclusive() {
super(MAXINCLUSIVE_TYPE, MAXINCLUSIVE_FACET_BIT, MAXEXCLUSIVE_FACET_BIT | MAXINCLUSIVE_FACET_BIT);
}
}
public static class WhiteSpace extends TextFacet
{
//
// Value set information
public static final int PRESERVE_WHITESPACE = 1;
public static final int REPLACE_WHITESPACE = 2;
public static final int COLLAPSE_WHITESPACE = 3;
public static final EnumSet s_finalValues = new EnumSet(PRESERVE_WHITESPACE, new String[] { "preserve",
"replace", "collapse" });
//
// Instance data
private int m_whitespaceType;
/**
* Constructor. Just sets element type in base class.
*/
public WhiteSpace() {
super(WHITESPACE_TYPE, WHITESPACE_FACET_BIT, WHITESPACE_FACET_BIT);
}
/**
* Get whitespace handling type code.
*
* @return type code for whitespace handling
*/
public int getWhitespaceType() {
return m_whitespaceType;
}
//
// Validation methods
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check for valid attribute values
m_whitespaceType = s_finalValues.getValue(getValue());
if (m_whitespaceType < 0) {
vctx.addError("'whitespace' attribute value '" + getValue() + "' is not allowed", this);
}
// continue with parent class prevalidation
super.prevalidate(vctx);
}
}
public abstract static class NoFixedFacet extends FacetElement
{
/** List of allowed attribute names (including "id" from base). */
public static final StringArray s_allowedAttributes = new StringArray(new String[] { "value" },
AnnotatedBase.s_allowedAttributes);
//
// Instance data
/** "value" attribute value. */
private String m_value;
/**
* Constructor. Just passes on the element type to base class.
*
* @param type
* @param bit mask
* @param exclude exclusion bit mask
*/
public NoFixedFacet(int type, int bit, int exclude) {
super(type, bit, exclude);
}
/**
* Get "value" attribute value.
*
* @return value attribute value
*/
public String getValue() {
return m_value;
}
/**
* Set "value" attribute value.
*
* @param value value attribute value
*/
public void setValue(String value) {
m_value = value;
}
//
// Validation methods
/**
* Make sure all attributes are defined.
*
* @param uctx unmarshalling context
* @exception JiBXException on unmarshalling error
*/
protected void preset(IUnmarshallingContext uctx) throws JiBXException {
validateAttributes(uctx, s_allowedAttributes);
super.preset(uctx);
}
}
public static class Enumeration extends NoFixedFacet
{
/**
* Constructor. Just sets element type in base class.
*/
public Enumeration() {
super(ENUMERATION_TYPE, ENUMERATION_FACET_BIT, 0);
}
}
public static class Pattern extends NoFixedFacet
{
/**
* Constructor. Just sets element type in base class.
*/
public Pattern() {
super(PATTERN_TYPE, PATTERN_FACET_BIT, 0);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/SchemaLocationRequiredBase.java 0000644 0001750 0001750 00000007242 11252237150 030756 0 ustar twerner twerner /*
Copyright (c) 2006-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import java.io.IOException;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.ISchemaResolver;
import org.jibx.schema.validation.ValidationContext;
/**
* Base class for elements referencing an external schema by using a required
* 'schemaLocation' attribute. During prevalidation this first reads the
* referenced schema, so that it'll automatically be included in the
* prevalidation pass.
*
* @author Dennis M. Sosnoski
*/
public abstract class SchemaLocationRequiredBase extends SchemaLocationBase
{
/**
* Constructor.
*
* @param type element type
*/
protected SchemaLocationRequiredBase(int type) {
super(type);
}
//
// Base class overrides
/**
* Prevalidation for schema location subclass with the schema specified by a
* required'schemaLocation' attribute.
*
* @param vctx validation context
*/
public void prevalidate(ValidationContext vctx) {
String location = getLocation();
if (location == null) {
vctx.addFatal("Missing required 'schemaLocation' value", this);
} else {
try {
// find or load referenced schema
SchemaElement curschema = vctx.getCurrentSchema();
ISchemaResolver resolver =
curschema.getResolver().resolve(location, null);
SchemaElement schema = vctx.getSchemaById(resolver.getId());
if (schema == null) {
schema = readSchema(vctx, resolver);
vctx.setSchema(resolver.getId(), schema);
schema.setResolver(resolver);
}
setReferencedSchema(schema);
if (schema.getEffectiveNamespace() == null) {
schema.setEffectiveNamespace(curschema.getEffectiveNamespace());
}
} catch (JiBXException e) {
vctx.addFatal("Error loading schema: " + e.getMessage(), this);
} catch (IOException e) {
vctx.addFatal("Error loading schema: " + e.getMessage(), this);
}
}
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/AnnotationItem.java 0000644 0001750 0001750 00000006467 11155044604 026534 0 ustar twerner twerner /*
Copyright (c) 2006-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.jibx.util.LazyList;
import org.w3c.dom.Node;
/**
* Annotation item base class. The actual annotation elements are defined as
* subclasses.
*/
public abstract class AnnotationItem extends SchemaBase
{
/** Annotation item source. */
private String m_source;
/** Content of annotation item. */
private List m_content;
/**
* Constructor.
*
* @param type element type
*/
protected AnnotationItem(int type) {
super(type);
m_content = new ArrayList();
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.SchemaBase#getChildCount()
*/
public int getChildCount() {
return 0;
}
/* (non-Javadoc)
* @see org.jibx.schema.SchemaBase#getChildIterator()
*/
public Iterator getChildIterator() {
return LazyList.EMPTY_ITERATOR;
}
//
// Access methods
/**
* Get annotation item source.
*
* @return item source
*/
public String getSource() {
return m_source;
}
/**
* Set annotation item source.
*
* @param source item source
*/
public void setSource(String source) {
m_source = source;
}
/**
* Get annotation item content list. This is a list consisting of DOM
* nodes.
*
* @return annotation content list
*/
public final List getContent() {
return m_content;
}
/**
* Clear annotation item content.
*/
public final void clearContent() {
m_content.clear();
}
/**
* Add annotation item content node.
*
* @param node annotation item content node
*/
public final void addContent(Node node) {
m_content.add(node);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/SelectionBase.java 0000644 0001750 0001750 00000007631 11072342166 026317 0 ustar twerner twerner /*
* Copyright (c) 2008, Dennis M. Sosnoski. 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. Neither the name of
* JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* 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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Base representation for selector and field elements. Inner classes are used for the subclass elements.
*
* @author Dennis M. Sosnoski
*/
public class SelectionBase extends AnnotatedBase
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes = new StringArray(new String[] { "xpath" },
AnnotatedBase.s_allowedAttributes);
//
// Instance data
/** 'xpath' attribute value. */
private String m_xpath;
/**
* Constructor.
*
* @param type
*/
public SelectionBase(int type) {
super(type);
}
//
// Base class overrides
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Access methods
/**
* Get 'xpath' attribute value.
*
* @return xpath
*/
public String getXPath() {
return m_xpath;
}
/**
* Set 'xpath' attribute value.
*
* @param xpath
*/
public void setXPath(String xpath) {
m_xpath = xpath;
}
//
// Validation methods
/*
* (non-Javadoc)
*
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
if (getXPath() == null) {
vctx.addError("The 'xpath' attribute is required for 'selection' and 'field' elements", this);
}
super.prevalidate(vctx);
}
//
// Actual element subclasses
public static class SelectorElement extends SelectionBase
{
/**
* Constructor. Just sets element type in base class.
*/
public SelectorElement() {
super(SELECTOR_TYPE);
}
}
public static class FieldElement extends SelectionBase
{
/**
* Constructor. Just sets element type in base class.
*/
public FieldElement() {
super(FIELD_TYPE);
}
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/NotationElement.java 0000644 0001750 0001750 00000011454 11062041162 026671 0 ustar twerner twerner /*
Copyright (c) 2006, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.QName;
import org.jibx.schema.INamed;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Model component for notation element, which can only be used as a
* direct child of the schema element.
*
* @author Dennis M. Sosnoski
*/
public class NotationElement extends AnnotatedBase implements INamed
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "name", "public", "system" },
AnnotatedBase.s_allowedAttributes);
/** "public" attribute value. */
private String m_public;
/** "system" attribute code for element. */
private String m_system;
/** 'name' attribute value. */
private String m_name;
/** Qualified name (only defined after validation). */
private QName m_qname;
/**
* Constructor.
*/
public NotationElement() {
super(NOTATION_TYPE);
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Access methods
/**
* Get "public" attribute value.
*
* @return public attribute value
*/
public String getPublic() {
return m_public;
}
/**
* Set "public" attribute value.
*
* @param publc public attribute value
*/
public void setPublic(String publc) {
m_public = publc;
}
/**
* Get "system" attribute value.
*
* @return system attribute value
*/
public String getSystem() {
return m_system;
}
/**
* Set "system" attribute value.
*
* @param systm system attribute value
*/
public void setSystem(String systm) {
m_system = systm;
}
/**
* Get 'name' attribute value.
*
* @return name
*/
public String getName() {
return m_name;
}
/**
* Set 'name' attribute value.
*
* @param name
*/
public void setName(String name) {
m_name = name;
}
/**
* Get qualified name for element. This method is only usable after
* prevalidation.
*
* @return qname (null if not defined)
*/
public QName getQName() {
return m_qname;
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// check for missing items
if (m_name == null) {
vctx.addError("Missing required 'name' attribute", this);
} else {
m_qname = new QName(vctx.getCurrentSchema().getEffectiveNamespace(),
getName());
}
if (m_public == null) {
vctx.addError("Missing required 'public' attribute", this);
}
// continue with parent class prevalidation
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/SchemaElement.java 0000644 0001750 0001750 00000030462 11062041164 026300 0 ustar twerner twerner /*
Copyright (c) 2006-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.apache.log4j.Logger;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.ISchemaResolver;
import org.jibx.schema.NameRegister;
import org.jibx.schema.TreeWalker;
import org.jibx.schema.attributes.FormChoiceAttribute;
import org.jibx.schema.support.Conversions;
import org.jibx.schema.types.AllEnumSet;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.LazyList;
import org.jibx.util.StringArray;
/**
* Model component for schema element.
*
* @author Dennis M. Sosnoski
*/
public class SchemaElement extends OpenAttrBase
{
/** Logger for class. */
private static final Logger s_logger = Logger.getLogger(TreeWalker.class.getName());
/** List of allowed attribute names */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "attributeFormDefault", "blockDefault",
"elementFormDefault", "finalDefault", "id", "targetNamespace",
"version" });
/** Mask bits for schema reference child elements. */
private static final long SCHEMA_REFERENCE_MASK = ELEMENT_MASKS[ANNOTATION_TYPE] |
ELEMENT_MASKS[INCLUDE_TYPE] | ELEMENT_MASKS[IMPORT_TYPE] |
ELEMENT_MASKS[REDEFINE_TYPE];
/** Mask bits for top-level definition child elements. */
private static final long TOP_LEVEL_DEFINITION_MASK = ELEMENT_MASKS[ANNOTATION_TYPE] |
ELEMENT_MASKS[ATTRIBUTE_TYPE] | ELEMENT_MASKS[ATTRIBUTEGROUP_TYPE] |
ELEMENT_MASKS[COMPLEXTYPE_TYPE] | ELEMENT_MASKS[ELEMENT_TYPE] |
ELEMENT_MASKS[GROUP_TYPE] | ELEMENT_MASKS[NOTATION_TYPE] |
ELEMENT_MASKS[SIMPLETYPE_TYPE];
//
// Instance data
/** Filtered list of schema reference child elements. */
private final FilteredSegmentList m_schemaChildren;
/** Filtered list of top-level definition child elements. */
private final FilteredSegmentList m_topLevelChildren;
/** Schemas which directly reference this schema. */
private final LazyList m_dependentSchemas;
/** 'attributeFormDefault' attribute value (-1 if not set). */
private int m_attributeFormDefaultType;
/** 'elementFormDefault' attribute value (-1 if not set). */
private int m_elementFormDefaultType;
/** 'blockDefault' attribute value. */
private AllEnumSet m_blockDefault;
/** 'finalDefault' attribute value. */
private AllEnumSet m_finalDefault;
/** "id" attribute value. */
private String m_id;
/** 'targetNamespace' attribute value. */
private String m_targetNamespace;
/** Effective namespace overriding the target namespace (null if unused). */
private String m_effectiveNamespace;
/** 'version' attribute value. */
private String m_version;
/** Resolver for this schema. */
private ISchemaResolver m_resolver;
/** Register for names from this context. */
private NameRegister m_register;
/**
* Constructor.
*/
public SchemaElement() {
super(SCHEMA_TYPE);
m_schemaChildren = new FilteredSegmentList(getChildrenWritable(),
SCHEMA_REFERENCE_MASK, this);
m_topLevelChildren = new FilteredSegmentList(getChildrenWritable(),
TOP_LEVEL_DEFINITION_MASK, m_schemaChildren, this);
m_dependentSchemas = new LazyList();
m_blockDefault = new AllEnumSet(ElementElement.s_blockValues,
"blockDefault");
m_finalDefault = new AllEnumSet(ElementElement.s_derivationValues,
"finalDefault");
m_register = new NameRegister();
m_attributeFormDefaultType = -1;
m_elementFormDefaultType = -1;
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.ElementBase#preset(org.jibx.runtime.IUnmarshallingContext)
*/
protected void preset(IUnmarshallingContext ictx) throws JiBXException {
validateAttributes(ictx, s_allowedAttributes);
super.preset(ictx);
}
//
// Access methods
/**
* Get list of schema-related child elements.
*
* @return child list
*/
public FilteredSegmentList getSchemaChildren() {
return m_schemaChildren;
}
/**
* Get list of top-level definition child elements.
*
* @return child list
*/
public FilteredSegmentList getTopLevelChildren() {
return m_topLevelChildren;
}
/**
* Get 'attributeFormDefault' attribute type code.
*
* @return type
*/
public int getAttributeFormDefault() {
return m_attributeFormDefaultType;
}
/**
* Set 'attributeFormDefault' attribute type code.
*
* @param type
*/
public void setAttributeFormDefault(int type) {
FormChoiceAttribute.s_formValues.checkValue(type);
m_attributeFormDefaultType = type;
}
/**
* Get 'attributeFormDefault' attribute text.
*
* @return text (null if not set)
*/
public String getAttributeFormDefaultText() {
if (m_attributeFormDefaultType >= 0) {
return FormChoiceAttribute.s_formValues.
getName(m_attributeFormDefaultType);
} else {
return null;
}
}
/**
* Set 'attributeFormDefault' attribute text. This method is provided only
* for use when unmarshalling.
*
* @param text
* @param ictx
*/
private void setAttributeFormDefaultText(String text,
IUnmarshallingContext ictx) {
m_attributeFormDefaultType = Conversions.convertEnumeration(text,
FormChoiceAttribute.s_formValues, "attributeFormDefault", ictx);
}
/**
* Get 'elementFormDefault' attribute type code.
*
* @return type
*/
public int getElementFormDefault() {
return m_elementFormDefaultType;
}
/**
* Set 'elementFormDefault' attribute type code.
*
* @param type
*/
public void setElementFormDefault(int type) {
FormChoiceAttribute.s_formValues.checkValue(type);
m_elementFormDefaultType = type;
}
/**
* Get 'elementFormDefault' attribute text.
*
* @return text (null if not set)
*/
public String getElementFormDefaultText() {
if (m_elementFormDefaultType >= 0) {
return FormChoiceAttribute.s_formValues.
getName(m_elementFormDefaultType);
} else {
return null;
}
}
/**
* Set 'elementFormDefault' attribute text. This method is provided only
* for use when unmarshalling.
*
* @param text
* @param ictx
*/
private void setElementFormDefaultText(String text,
IUnmarshallingContext ictx) {
m_elementFormDefaultType = Conversions.convertEnumeration(text,
FormChoiceAttribute.s_formValues, "elementFormDefault", ictx);
}
/**
* Get 'blockDefault' attribute.
*
* @return block default
*/
public AllEnumSet getBlock() {
return m_blockDefault;
}
/**
* Get 'finalDefault' attribute.
*
* @return final default
*/
public AllEnumSet getFinal() {
return m_finalDefault;
}
/**
* Get 'targetNamespace' attribute. Note that for most purposes the
* {@link #getEffectiveNamespace()} method should be used instead, since
* that method returns the namespace which should be used for definitions
* within this schema.
*
* @return target namespace (null if none)
*/
public String getTargetNamespace() {
return m_targetNamespace;
}
/**
* Set 'targetNamespace' attribute.
*
* @param tns target namespace (null if none)
*/
public void setTargetNamespace(String tns) {
m_targetNamespace = tns;
}
/**
* Get the effective namespace which applies to this schema. This will
* differ from the 'targetNamespace' attribute in the case where a
* no-namespace schema is included (directly or indirectly) into a
* namespaced schema.
*
* @return effective namespace (null if none)
*/
public String getEffectiveNamespace() {
if (m_targetNamespace == null) {
return m_effectiveNamespace;
} else {
return m_targetNamespace;
}
}
/**
* Set the effective namespace to be applied to this schema.
*
* @param ens effective namespace (null if the same as 'targetNamespace' attribute)
*/
public void setEffectiveNamespace(String ens) {
m_effectiveNamespace = ens;
}
/**
* Get 'version' attribute.
*
* @return version
*/
public String getVersion() {
return m_version;
}
/**
* Set 'version' attribute.
*
* @param version
*/
public void setVersion(String version) {
m_version = version;
}
/**
* Get resolver.
*
* @return resolver
*/
public ISchemaResolver getResolver() {
return m_resolver;
}
/**
* Set resolver.
*
* @param resolver
*/
public void setResolver(ISchemaResolver resolver) {
m_resolver = resolver;
}
/**
* Get register for named components of schema.
*
* @return register
*/
public NameRegister getRegister() {
return m_register;
}
//
// Convenience methods based on defaults
/**
* Check if elements are qualified by default.
*
* @return true if qualified, false if not
*/
public boolean isElementQualifiedDefault() {
return m_elementFormDefaultType == FormChoiceAttribute.QUALIFIED_FORM;
}
/**
* Check if attributes are qualified by default.
*
* @return true if qualified, false if not
*/
public boolean isAttributeQualifiedDefault() {
return m_attributeFormDefaultType == FormChoiceAttribute.QUALIFIED_FORM;
}
//
// Validation methods
/**
* Get the schema name for logging validation.
*
* @return name
*/
private String getName() {
ISchemaResolver resolver = getResolver();
if (resolver == null) {
return "{no name}";
} else {
return resolver.getName();
}
}
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#validate(org.jibx.schema.ValidationContext)
*/
public void validate(ValidationContext vctx) {
s_logger.debug("Validating schema " + getName());
super.validate(vctx);
}
public void prevalidate(ValidationContext vctx) {
s_logger.debug("Prevalidating schema " + getName());
super.prevalidate(vctx);
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/ComplexExtensionElement.java 0000644 0001750 0001750 00000003746 10624256130 030415 0 ustar twerner twerner /*
Copyright (c) 2006-2007, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
/**
* Definition for extension element used with a complex type.
*
* @author Dennis M. Sosnoski
*/
public class ComplexExtensionElement extends CommonComplexModification
{
/**
* Constructor.
*/
public ComplexExtensionElement() {
super(EXTENSION_TYPE);
}
//
// Base class overrides
/* (non-Javadoc)
* @see org.jibx.schema.elements.CommonTypeDerivation#isExtension()
*/
public boolean isExtension() {
return true;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/SchemaLocationBase.java 0000644 0001750 0001750 00000011547 11167465000 027262 0 ustar twerner twerner /*
Copyright (c) 2006-2009, Dennis M. Sosnoski.
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import java.io.IOException;
import org.jibx.runtime.BindingDirectory;
import org.jibx.runtime.IBindingFactory;
import org.jibx.runtime.IUnmarshallable;
import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.JiBXException;
import org.jibx.schema.ISchemaResolver;
import org.jibx.schema.SchemaUtils;
import org.jibx.schema.validation.ValidationContext;
import org.jibx.util.StringArray;
/**
* Base class for elements referencing an external schema. Subclasses need to
* set the referenced schema during the prevalidation pass, so that the
* referenced schema will be included in the prevalidation processing.
*
* @author Dennis M. Sosnoski
*/
public abstract class SchemaLocationBase extends AnnotatedBase
{
/** List of allowed attribute names. */
public static final StringArray s_allowedAttributes =
new StringArray(new String[] { "schemaLocation" },
AnnotatedBase.s_allowedAttributes);
//
// Instance data
/** 'schemaLocation' attribute value. */
private String m_location;
/** Referenced schema definition. */
private SchemaElement m_schema;
/**
* Constructor.
*
* @param type element type
*/
protected SchemaLocationBase(int type) {
super(type);
}
/**
* Get the effective namespace to be applied to the referenced schema. This
* must be implemented by subclasses to return the namespace to be applied
* to the schema, if that namespace is different from what is specified in
* the schema itself.
*
* @return namespace
*/
protected abstract String getEffectiveNamespace();
/**
* Load a schema from a resolver.
*
* @param vctx validation context
* @param resolver
* @return loaded schema
* @throws JiBXException
* @throws IOException
*/
protected SchemaElement readSchema(ValidationContext vctx,
ISchemaResolver resolver) throws JiBXException, IOException {
IBindingFactory factory = BindingDirectory.getFactory
(SchemaUtils.XS_PREFIX_BINDING, SchemaElement.class);
IUnmarshallingContext uctx = factory.createUnmarshallingContext();
uctx.setDocument(resolver.getContent(), resolver.getId(), null);
uctx.setUserContext(vctx);
SchemaElement schema = new SchemaElement();
((IUnmarshallable)schema).unmarshal(uctx);
return schema;
}
//
// Access methods
/**
* Get 'schemaLocation' attribute value.
*
* @return 'schemaLocation' value
*/
public String getLocation() {
return m_location;
}
/**
* Set 'schemaLocation' attribute value.
*
* @param location 'schemaLocation' value
*/
public void setLocation(String location) {
m_location = location;
}
/**
* Set referenced schema. This method is supplied for the use of subclasses
* which load the schema through some means other than the 'schemaLocation'
* attribute value.
*
* @param schema schema element
*/
protected void setReferencedSchema(SchemaElement schema) {
m_schema = schema;
}
/**
* Get referenced schema. This method is only usable after prevalidation.
*
* @return schema (null if loading failed)
*/
public SchemaElement getReferencedSchema() {
return m_schema;
}
} libjibx1.2-java-1.2.3/build/src/org/jibx/schema/elements/CommonContentBase.java 0000644 0001750 0001750 00000010122 10624256130 027137 0 ustar twerner twerner /*
Copyright (c) 2006, Dennis M. Sosnoski
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.
* Neither the name of JiBX nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
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 OWNER 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.jibx.schema.elements;
import org.jibx.schema.validation.ValidationContext;
/**
* Common base for simpleContent and complexContent elements.
*
* @author Dennis M. Sosnoski
*/
public abstract class CommonContentBase extends AnnotatedBase
{
/** Mask bits for content derivation child elements. */
private long CONTENT_DERIVATION_MASK = ELEMENT_MASKS[EXTENSION_TYPE] |
ELEMENT_MASKS[RESTRICTION_TYPE];
//
// Instance data
/** Filtered list of content derivation elements (must be exactly one). */
private final FilteredSegmentList m_contentDerivationList;
/**
* Constructor.
*
* @param type actual element type
*/
public CommonContentBase(int type) {
super(type);
m_contentDerivationList = new FilteredSegmentList(getChildrenWritable(),
CONTENT_DERIVATION_MASK, this);
}
//
// Access methods
/**
* Check if a complex content definition.
*
* @return true if complex content, false if
* simple content
*/
public abstract boolean isComplexContent();
/**
* Get derivation child element. This is either an <extension> or a
* <restriction> element.
*
* @return derivation element, or null if not yet set
*/
public CommonTypeDerivation getDerivation() {
return m_contentDerivationList.size() > 0 ?
(CommonTypeDerivation)m_contentDerivationList.get(0) : null;
}
/**
* Set derivation child element. This is either an <extension> or a
* <restriction> element.
*
* @param element derivation element, or null if unsetting
*/
public void setDerivation(CommonTypeDerivation element) {
m_contentDerivationList.clear();
if (element != null) {
m_contentDerivationList.add(element);
element.setParent(this);
}
}
//
// Validation methods
/* (non-Javadoc)
* @see org.jibx.schema.ComponentBase#prevalidate(org.jibx.schema.ValidationContext)
*/
public void prevalidate(ValidationContext vctx) {
// make sure exactly one content definition item is present
if (m_contentDerivationList.size() == 0 ) {
vctx.addError("Missing required or child element", this);
} else if (m_contentDerivationList.size() > 1) {
vctx.addError("Only one or
