Слияние docx4j 17.3.5 в wordpdf-core и форк FO-рендерера 2.11-docx4j.8 в реактор
PR checks / web (pull_request) Successful in 38s
PR checks / java (pull_request) Successful in 18m31s

- wordpdf-core/src/main/java впитаны исходники docx4j-core, -export-fo,
  -chart-render, -JAXB-ReferenceImpl, -copy, -generated-objects (17.3.5) +
  сгенерированная XJC JAXB-модель; ресурсы — тем же путём; артефакты группы
  org.docx4j из внешних репозиториев больше не подключаются
- vendor/fop: форк docx4j-fo-renderer 2.11-docx4j.8 (util/events/core/fop)
  собирается в реакторе вместо jar из Nexus
- docx2fo.xslt перевендорен со стилем 17.3.5, оба AUDIT-FIX-патча перенесены;
  дрейф-гейт vendoredXsltTracksJarCopy зелёный
- upstream-тесты docx4j перенесены в src/test/java/org (658 классов, вне гейта);
  execution upstream-docx4j-tests в профиле upstream-tests (./mise.sh run
  upstream-tests, в pr.yml non-blocking шаг): 3470 тестов, 3457 зелёных,
  13 красных — категории окружения/калибровки хоста и следствий слияния
  classpath задокументированы в docs/agent/testing.md
- surefire: провайдер SLF4J фиксируется коротким slf4j.provider по execution;
  перенесён upstream logback.xml (root=DEBUG без конфига ломает visitor-экспорт
  VML); upstream-форки пинят JDK JAXP-фабрики; PMD/JaCoCo исключают org/**
- wordpdf-app: без изменений кода (зависит от слитого ядра); тесты 44/44
- документация синхронизирована (AGENTS.md, README, docs/agent/*), mise task
  upstream-tests
This commit is contained in:
Pjandro
2026-11-08 02:54:49 +00:00
parent f41ac54072
commit 8529b6877b
10191 changed files with 1694473 additions and 75 deletions
+105
View File
@@ -0,0 +1,105 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.docx4j</groupId>
<artifactId>docx4j-fo-renderer-util</artifactId>
<name>docx4j FO renderer utilities</name>
<description>docx4j FO renderer utilities, based on Apache FOP's main branch after 2.11 (fop-util). This is a modified distribution derived from Apache FOP (its main branch after the 2.11 release). It is maintained by Plutext/docx4j and is not an Apache Software Foundation release. Apache FOP is a trademark of the Apache Software Foundation.</description>
<parent>
<groupId>org.docx4j</groupId>
<artifactId>docx4j-fo-renderer-parent</artifactId>
<version>2.11-docx4j.8</version>
</parent>
<dependencies>
<!-- compile deps -->
<dependency>
<groupId>org.apache.xmlgraphics</groupId>
<artifactId>xmlgraphics-commons</artifactId>
<version>${xmlgraphics.commons.version}</version>
</dependency>
<!-- test deps -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<configuration>
<archive>
<manifestEntries>
<Automatic-Module-Name>org.apache.xmlgraphics.fop.util</Automatic-Module-Name>
</manifestEntries>
</archive>
</configuration>
</plugin>
<!-- junit testing -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<includes>
<include>**/*TestCase.java</include>
</includes>
<redirectTestOutputToFile>true</redirectTestOutputToFile>
</configuration>
</plugin>
<!-- code analysis - checkstyle -->
<plugin>
<artifactId>maven-checkstyle-plugin</artifactId>
<configuration>
<configLocation>${project.baseUri}../fop-core/src/tools/resources/checkstyle/checkstyle.xml</configLocation>
<headerLocation>${project.baseUri}../fop-core/src/tools/resources/checkstyle/LICENSE.txt</headerLocation>
<includeResources>false</includeResources>
<includeTestResources>false</includeTestResources>
<linkXRef>false</linkXRef>
<logViolationsToConsole>true</logViolationsToConsole>
<suppressionsLocation>${project.baseUri}../fop-core/src/tools/resources/checkstyle/suppressions.xml</suppressionsLocation>
<violationSeverity>warning</violationSeverity>
</configuration>
</plugin>
<!-- code analysis - findbugs -->
<plugin>
<groupId>com.github.spotbugs</groupId>
<artifactId>spotbugs-maven-plugin</artifactId>
<version>${findbugs.plugin.version}</version>
<configuration>
<excludeFilterFile>../fop-core/src/tools/resources/findbugs/exclusions.xml</excludeFilterFile>
<effort>Max</effort>
<threshold>Low</threshold>
</configuration>
</plugin>
</plugins>
<resources>
<resource>
<directory>src/main/resources</directory>
</resource>
<resource>
<directory>${basedir}/..</directory>
<includes>
<include>LICENSE</include>
<include>NOTICE</include>
</includes>
<targetPath>META-INF</targetPath>
</resource>
</resources>
<testResources>
<testResource>
<directory>src/test/resources</directory>
<includes>
<include>**/*</include>
</includes>
</testResource>
</testResources>
</build>
</project>
@@ -0,0 +1,65 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* $Id$ */
package org.apache.fop.utils;
import javax.xml.transform.ErrorListener;
import javax.xml.transform.TransformerException;
import org.apache.commons.logging.Log;
/**
* Standard ErrorListener implementation for in-FOP use. Some Xalan-J versions don't properly
* re-throw exceptions.
*/
public class DefaultErrorListener implements ErrorListener {
private Log log;
/**
* Main constructor
* @param log the log instance to send log events to
*/
public DefaultErrorListener(Log log) {
this.log = log;
}
/**
* {@inheritDoc}
*/
public void warning(TransformerException exc) {
log.warn(exc.toString());
}
/**
* {@inheritDoc}
*/
public void error(TransformerException exc) throws TransformerException {
throw exc;
}
/**
* {@inheritDoc}
*/
public void fatalError(TransformerException exc)
throws TransformerException {
throw exc;
}
}
@@ -0,0 +1,397 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* $Id$ */
package org.apache.fop.utils;
import java.io.IOException;
import java.io.InputStream;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Locale;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.Properties;
import java.util.ResourceBundle;
import java.util.Stack;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;
import org.apache.xmlgraphics.util.QName;
/**
* This class is a ResourceBundle that loads its contents from XML files instead of properties
* files (like PropertiesResourceBundle).
* <p>
* The XML format for this resource bundle implementation is the following
* (the same as Apache Cocoon's XMLResourceBundle):
* <pre>
* &lt;catalogue xml:lang="en"&gt;
* &lt;message key="key1"&gt;Message &lt;br/&gt; Value 1&lt;/message&gt;
* &lt;message key="key2"&gt;Message &lt;br/&gt; Value 1&lt;/message&gt;
* ...
* &lt;/catalogue&gt;
* </pre>
*/
public class XMLResourceBundle extends ResourceBundle {
//Note: Some code here has been copied and adapted from Apache Harmony!
private Properties resources = new Properties();
private Locale locale;
/**
* Creates a resource bundle from an InputStream.
* @param in the stream to read from
* @throws IOException if an I/O error occurs
*/
public XMLResourceBundle(InputStream in) throws IOException {
try {
SAXParserFactory factory = SAXParserFactory.newInstance();
factory.setNamespaceAware(true);
XMLReader reader = factory.newSAXParser().getXMLReader();
reader.setContentHandler(new CatalogueHandler());
reader.parse(new InputSource(in));
} catch (ParserConfigurationException | SAXException e) {
throw new IOException("Error while parsing XML resource bundle: " + e.getMessage());
}
}
/**
* Gets a resource bundle using the specified base name, default locale, and class loader.
* @param baseName the base name of the resource bundle, a fully qualified class name
* @param loader the class loader from which to load the resource bundle
* @return a resource bundle for the given base name and the default locale
* @throws MissingResourceException if no resource bundle for the specified base name can be
* found
* @see java.util.ResourceBundle#getBundle(String)
*/
public static ResourceBundle getXMLBundle(String baseName, ClassLoader loader)
throws MissingResourceException {
return getXMLBundle(baseName, Locale.getDefault(), loader);
}
/**
* Gets a resource bundle using the specified base name, locale, and class loader.
* @param baseName the base name of the resource bundle, a fully qualified class name
* @param locale the locale for which a resource bundle is desired
* @param loader the class loader from which to load the resource bundle
* @return a resource bundle for the given base name and locale
* @throws MissingResourceException if no resource bundle for the specified base name can be
* found
* @see java.util.ResourceBundle#getBundle(String, Locale, ClassLoader)
*/
public static ResourceBundle getXMLBundle(String baseName, Locale locale, ClassLoader loader)
throws MissingResourceException {
if (loader == null) {
throw new NullPointerException("loader must not be null");
}
if (baseName == null) {
throw new NullPointerException("baseName must not be null");
}
assert locale != null;
ResourceBundle bundle;
if (!locale.equals(Locale.getDefault())) {
bundle = handleGetXMLBundle(baseName, "_" + locale, false, loader);
if (bundle != null) {
return bundle;
}
}
bundle = handleGetXMLBundle(baseName, "_" + Locale.getDefault(), true, loader);
if (bundle != null) {
return bundle;
}
throw new MissingResourceException(
baseName + " (" + locale + ")", baseName + '_' + locale, null);
}
static class MissingBundle extends ResourceBundle {
public Enumeration getKeys() {
return null;
}
public Object handleGetObject(String name) {
return null;
}
}
private static final ResourceBundle MISSING = new MissingBundle();
private static final ResourceBundle MISSINGBASE = new MissingBundle();
private static Map cache = new java.util.WeakHashMap();
//<Object, Hashtable<String, ResourceBundle>>
private static ResourceBundle handleGetXMLBundle(String base, String locale,
boolean loadBase, final ClassLoader loader) {
XMLResourceBundle bundle = null;
String bundleName = base + locale;
Object cacheKey = loader != null ? (Object) loader : (Object) "null";
Hashtable loaderCache; //<String, ResourceBundle>
synchronized (cache) {
loaderCache = (Hashtable)cache.get(cacheKey);
if (loaderCache == null) {
loaderCache = new Hashtable();
cache.put(cacheKey, loaderCache);
}
}
ResourceBundle result = (ResourceBundle)loaderCache.get(bundleName);
if (result != null) {
if (result == MISSINGBASE) {
return null;
}
if (result == MISSING) {
if (!loadBase) {
return null;
}
String extension = strip(locale);
if (extension == null) {
return null;
}
return handleGetXMLBundle(base, extension, loadBase, loader);
}
return result;
}
final String fileName = bundleName.replace('.', '/') + ".xml";
InputStream stream = (InputStream)AccessController
.doPrivileged(new PrivilegedAction() {
public Object run() {
return loader == null
? ClassLoader.getSystemResourceAsStream(fileName)
: loader.getResourceAsStream(fileName);
}
});
if (stream != null) {
try {
try {
bundle = new XMLResourceBundle(stream);
} finally {
stream.close();
}
bundle.setLocale(locale);
} catch (IOException e) {
throw new MissingResourceException(e.getMessage(), base, null);
}
}
String extension = strip(locale);
if (bundle != null) {
if (extension != null) {
ResourceBundle parent = handleGetXMLBundle(base, extension, true,
loader);
if (parent != null) {
bundle.setParent(parent);
}
}
loaderCache.put(bundleName, bundle);
return bundle;
}
if (extension != null) {
ResourceBundle fallback = handleGetXMLBundle(base, extension, loadBase, loader);
if (fallback != null) {
loaderCache.put(bundleName, fallback);
return fallback;
}
}
loaderCache.put(bundleName, loadBase ? MISSINGBASE : MISSING);
return null;
}
private void setLocale(String name) {
String language = "";
String country = "";
String variant = "";
if (name.length() > 1) {
int nextIndex = name.indexOf('_', 1);
if (nextIndex == -1) {
nextIndex = name.length();
}
language = name.substring(1, nextIndex);
if (nextIndex + 1 < name.length()) {
int index = nextIndex;
nextIndex = name.indexOf('_', nextIndex + 1);
if (nextIndex == -1) {
nextIndex = name.length();
}
country = name.substring(index + 1, nextIndex);
if (nextIndex + 1 < name.length()) {
variant = name.substring(nextIndex + 1, name.length());
}
}
}
this.locale = new Locale(language, country, variant);
}
private static String strip(String name) {
int index = name.lastIndexOf('_');
if (index != -1) {
return name.substring(0, index);
}
return null;
}
private Enumeration getLocalKeys() {
return (Enumeration)resources.propertyNames();
}
/** {@inheritDoc} */
public Locale getLocale() {
return this.locale;
}
/** {@inheritDoc} */
public Enumeration getKeys() {
if (parent == null) {
return getLocalKeys();
}
return new Enumeration() {
private Enumeration local = getLocalKeys();
private Enumeration pEnum = parent.getKeys();
private Object nextElement;
private boolean findNext() {
if (nextElement != null) {
return true;
}
while (pEnum.hasMoreElements()) {
Object next = pEnum.nextElement();
if (!resources.containsKey(next)) {
nextElement = next;
return true;
}
}
return false;
}
public boolean hasMoreElements() {
if (local.hasMoreElements()) {
return true;
}
return findNext();
}
public Object nextElement() {
if (local.hasMoreElements()) {
return local.nextElement();
}
if (findNext()) {
Object result = nextElement;
nextElement = null;
return result;
}
// Cause an exception
return pEnum.nextElement();
}
};
}
/** {@inheritDoc} */
protected Object handleGetObject(String key) {
if (key == null) {
throw new NullPointerException("key must not be null");
}
return resources.get(key);
}
/** {@inheritDoc} */
public String toString() {
return "XMLResourceBundle: " + getLocale();
}
private class CatalogueHandler extends DefaultHandler {
private static final String CATALOGUE = "catalogue";
private static final String MESSAGE = "message";
private StringBuffer valueBuffer = new StringBuffer();
private Stack elementStack = new Stack();
private String currentKey;
private boolean isOwnNamespace(String uri) {
return ("".equals(uri));
}
private QName getParentElementName() {
return (QName)elementStack.peek();
}
/** {@inheritDoc} */
public void startElement(String uri, String localName, String qName,
Attributes atts) throws SAXException {
super.startElement(uri, localName, qName, atts);
QName elementName = new QName(uri, qName);
if (isOwnNamespace(uri)) {
if (CATALOGUE.equals(localName)) {
//nop
} else if (MESSAGE.equals(localName)) {
if (!CATALOGUE.equals(getParentElementName().getLocalName())) {
throw new SAXException(MESSAGE + " must be a child of " + CATALOGUE);
}
this.currentKey = atts.getValue("key");
} else {
throw new SAXException("Invalid element name: " + elementName);
}
} else {
//ignore
}
this.valueBuffer.setLength(0);
elementStack.push(elementName);
}
/** {@inheritDoc} */
public void endElement(String uri, String localName, String qName) throws SAXException {
super.endElement(uri, localName, qName);
elementStack.pop();
if (isOwnNamespace(uri)) {
if (CATALOGUE.equals(localName)) {
//nop
} else if (MESSAGE.equals(localName)) {
if (this.currentKey == null) {
throw new SAXException(
"current key is null (attribute 'key' might be mistyped)");
}
resources.put(this.currentKey, this.valueBuffer.toString());
this.currentKey = null;
}
} else {
//ignore
}
this.valueBuffer.setLength(0);
}
/** {@inheritDoc} */
public void characters(char[] ch, int start, int length) throws SAXException {
super.characters(ch, start, length);
valueBuffer.append(ch, start, length);
}
}
}
@@ -0,0 +1,483 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* $Id$ */
package org.apache.fop.utils.text;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import org.apache.xmlgraphics.util.Service;
/**
* Formats messages based on a template and with a set of named parameters. This is similar to
* {@link java.text.MessageFormat} but uses named parameters and supports conditional sub-groups.
* <p>
* Example:
* </p>
* <p><code>Missing field "{fieldName}"[ at location: {location}]!</code></p>
* <ul>
* <li>Curly brackets ("{}") are used for fields.</li>
* <li>Square brackets ("[]") are used to delimit conditional sub-groups. A sub-group is
* conditional when all fields inside the sub-group have a null value. In the case, everything
* between the brackets is skipped.</li>
* </ul>
*/
public class AdvancedMessageFormat {
/** Regex that matches "," but not "\," (escaped comma) */
public static final Pattern COMMA_SEPARATOR_REGEX = Pattern.compile("(?<!\\\\),");
private static final Map<String, PartFactory> PART_FACTORIES
= new java.util.HashMap<String, PartFactory>();
private static final List<ObjectFormatter> OBJECT_FORMATTERS
= new java.util.ArrayList<ObjectFormatter>();
private static final Map<Object, Function> FUNCTIONS
= new java.util.HashMap<Object, Function>();
private CompositePart rootPart;
static {
Iterator<Object> iter;
iter = Service.providers(PartFactory.class);
while (iter.hasNext()) {
PartFactory factory = (PartFactory)iter.next();
PART_FACTORIES.put(factory.getFormat(), factory);
}
iter = Service.providers(ObjectFormatter.class);
while (iter.hasNext()) {
OBJECT_FORMATTERS.add((ObjectFormatter)iter.next());
}
iter = Service.providers(Function.class);
while (iter.hasNext()) {
Function function = (Function)iter.next();
FUNCTIONS.put(function.getName(), function);
}
}
/**
* Construct a new message format.
* @param pattern the message format pattern.
*/
public AdvancedMessageFormat(CharSequence pattern) {
parsePattern(pattern);
}
private void parsePattern(CharSequence pattern) {
rootPart = new CompositePart(false);
StringBuffer sb = new StringBuffer();
parseInnerPattern(pattern, rootPart, sb, 0);
}
private int parseInnerPattern(CharSequence pattern, CompositePart parent,
StringBuffer sb, int start) {
assert sb.length() == 0;
int i = start;
int len = pattern.length();
loop:
while (i < len) {
char ch = pattern.charAt(i);
switch (ch) {
case '{':
if (sb.length() > 0) {
parent.addChild(new TextPart(sb.toString()));
sb.setLength(0);
}
i++;
int nesting = 1;
while (i < len) {
ch = pattern.charAt(i);
if (ch == '{') {
nesting++;
} else if (ch == '}') {
nesting--;
if (nesting == 0) {
i++;
break;
}
}
sb.append(ch);
i++;
}
parent.addChild(parseField(sb.toString()));
sb.setLength(0);
break;
case ']':
i++;
break loop; //Current composite is finished
case '[':
if (sb.length() > 0) {
parent.addChild(new TextPart(sb.toString()));
sb.setLength(0);
}
i++;
CompositePart composite = new CompositePart(true);
parent.addChild(composite);
i += parseInnerPattern(pattern, composite, sb, i);
break;
case '|':
if (sb.length() > 0) {
parent.addChild(new TextPart(sb.toString()));
sb.setLength(0);
}
parent.newSection();
i++;
break;
case '\\':
if (i < len - 1) {
i++;
ch = pattern.charAt(i);
}
sb.append(ch);
i++;
break;
default:
sb.append(ch);
i++;
break;
}
}
if (sb.length() > 0) {
parent.addChild(new TextPart(sb.toString()));
sb.setLength(0);
}
return i - start;
}
private Part parseField(String field) {
String[] parts = COMMA_SEPARATOR_REGEX.split(field, 3);
String fieldName = parts[0];
if (parts.length == 1) {
if (fieldName.startsWith("#")) {
return new FunctionPart(fieldName.substring(1));
} else {
return new SimpleFieldPart(fieldName);
}
} else {
String format = parts[1];
PartFactory factory = PART_FACTORIES.get(format);
if (factory == null) {
throw new IllegalArgumentException(
"No PartFactory available under the name: " + format);
}
if (parts.length == 2) {
return factory.newPart(fieldName, null);
} else {
return factory.newPart(fieldName, parts[2]);
}
}
}
private static Function getFunction(String functionName) {
return FUNCTIONS.get(functionName);
}
/**
* Formats a message with the given parameters.
* @param params a Map of named parameters (Contents: &lt;String, Object&gt;)
* @return the formatted message
*/
public String format(Map<String, Object> params) {
StringBuffer sb = new StringBuffer();
format(params, sb);
return sb.toString();
}
/**
* Formats a message with the given parameters.
* @param params a Map of named parameters (Contents: &lt;String, Object&gt;)
* @param target the target StringBuffer to write the formatted message to
*/
public void format(Map<String, Object> params, StringBuffer target) {
rootPart.write(target, params);
}
/**
* Represents a message template part. This interface is implemented by various variants of
* the single curly braces pattern ({field}, {field,if,yes,no} etc.).
*/
public interface Part {
/**
* Writes the formatted part to a string buffer.
* @param sb the target string buffer
* @param params the parameters to work with
*/
void write(StringBuffer sb, Map<String, Object> params);
/**
* Indicates whether there is any content that is generated by this message part.
* @param params the parameters to work with
* @return true if the part has content
*/
boolean isGenerated(Map<String, Object> params);
}
/**
* Implementations of this interface parse a field part and return message parts.
*/
public interface PartFactory {
/**
* Creates a new part by parsing the values parameter to configure the part.
* @param fieldName the field name
* @param values the unparsed parameter values
* @return the new message part
*/
Part newPart(String fieldName, String values);
/**
* Returns the name of the message part format.
* @return the name of the message part format
*/
String getFormat();
}
/**
* Implementations of this interface format certain objects to strings.
*/
public interface ObjectFormatter {
/**
* Formats an object to a string and writes the result to a string buffer.
* @param sb the target string buffer
* @param obj the object to be formatted
*/
void format(StringBuffer sb, Object obj);
/**
* Indicates whether a given object is supported.
* @param obj the object
* @return true if the object is supported by the formatter
*/
boolean supportsObject(Object obj);
}
/**
* Implementations of this interface do some computation based on the message parameters
* given to it. Note: at the moment, this has to be done in a local-independent way since
* there is no locale information.
*/
public interface Function {
/**
* Executes the function.
* @param params the message parameters
* @return the function result
*/
Object evaluate(Map<String, Object> params);
/**
* Returns the name of the function.
* @return the name of the function
*/
Object getName();
}
private static class TextPart implements Part {
private String text;
public TextPart(String text) {
this.text = text;
}
public void write(StringBuffer sb, Map<String, Object> params) {
sb.append(text);
}
public boolean isGenerated(Map<String, Object> params) {
return true;
}
/** {@inheritDoc} */
public String toString() {
return this.text;
}
}
private static class SimpleFieldPart implements Part {
private String fieldName;
public SimpleFieldPart(String fieldName) {
this.fieldName = fieldName;
}
public void write(StringBuffer sb, Map<String, Object> params) {
if (!params.containsKey(fieldName)) {
throw new IllegalArgumentException(
"Message pattern contains unsupported field name: " + fieldName);
}
Object obj = params.get(fieldName);
formatObject(obj, sb);
}
public boolean isGenerated(Map<String, Object> params) {
Object obj = params.get(fieldName);
return obj != null;
}
/** {@inheritDoc} */
public String toString() {
return "{" + this.fieldName + "}";
}
}
/**
* Formats an object to a string and writes the result to a string buffer. This method
* usually uses the object's <code>toString()</code> method unless there is an
* {@link ObjectFormatter} that supports the object. {@link ObjectFormatter}s are registered
* through the service provider mechanism defined by the JAR specification.
* @param obj the object to be formatted
* @param target the target string buffer
*/
public static void formatObject(Object obj, StringBuffer target) {
if (obj instanceof String) {
target.append(obj);
} else {
boolean handled = false;
for (ObjectFormatter formatter : OBJECT_FORMATTERS) {
if (formatter.supportsObject(obj)) {
formatter.format(target, obj);
handled = true;
break;
}
}
if (!handled) {
target.append(String.valueOf(obj));
}
}
}
private static class FunctionPart implements Part {
private Function function;
public FunctionPart(String functionName) {
this.function = getFunction(functionName);
if (this.function == null) {
throw new IllegalArgumentException("Unknown function: " + functionName);
}
}
public void write(StringBuffer sb, Map<String, Object> params) {
Object obj = this.function.evaluate(params);
formatObject(obj, sb);
}
public boolean isGenerated(Map<String, Object> params) {
Object obj = this.function.evaluate(params);
return obj != null;
}
/** {@inheritDoc} */
public String toString() {
return "{#" + this.function.getName() + "}";
}
}
private static class CompositePart implements Part {
protected List<Part> parts = new java.util.ArrayList<Part>();
private boolean conditional;
private boolean hasSections;
public CompositePart(boolean conditional) {
this.conditional = conditional;
}
private CompositePart(List<Part> parts) {
this.parts.addAll(parts);
this.conditional = true;
}
public void addChild(Part part) {
if (part == null) {
throw new NullPointerException("part must not be null");
}
if (hasSections) {
CompositePart composite = (CompositePart) this.parts.get(this.parts.size() - 1);
composite.addChild(part);
} else {
this.parts.add(part);
}
}
public void newSection() {
if (!hasSections) {
List<Part> p = this.parts;
//Dropping into a different mode...
this.parts = new java.util.ArrayList<Part>();
this.parts.add(new CompositePart(p));
hasSections = true;
}
this.parts.add(new CompositePart(true));
}
public void write(StringBuffer sb, Map<String, Object> params) {
if (hasSections) {
for (Part part : this.parts) {
if (part.isGenerated(params)) {
part.write(sb, params);
break;
}
}
} else {
if (isGenerated(params)) {
for (Part part : this.parts) {
part.write(sb, params);
}
}
}
}
public boolean isGenerated(Map<String, Object> params) {
if (hasSections) {
for (Part part : this.parts) {
if (part.isGenerated(params)) {
return true;
}
}
return false;
} else {
if (conditional) {
for (Part part : this.parts) {
if (!part.isGenerated(params)) {
return false;
}
}
}
return true;
}
}
/** {@inheritDoc} */
public String toString() {
return this.parts.toString();
}
}
public static String unescapeComma(String string) {
return string.replaceAll("\\\\,", ",");
}
}