com.helger.jaxb.builder.JAXBBuilderDefaultSettings Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ph-jaxb Show documentation
Special Java 1.8+ Library with extended JAXB support
The newest version!
/*
 * Copyright (C) 2014-2024 Philip Helger (www.helger.com)
 * philip[at]helger[dot]com
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.helger.jaxb.builder;

import java.nio.charset.Charset;

import javax.annotation.Nullable;
import javax.annotation.concurrent.GuardedBy;
import javax.annotation.concurrent.ThreadSafe;
import javax.xml.namespace.NamespaceContext;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.helger.commons.concurrent.SimpleReadWriteLock;
import com.helger.jaxb.validation.LoggingValidationEventHandler;
import com.helger.xml.serialize.write.XMLWriterSettings;

import jakarta.xml.bind.ValidationEventHandler;

/**
 * A class containing some default settings for the various JAXB builders.

 * Changes made in this class only effects instances that are created
 * afterwards. Existing instances are never changed.
 *
 * @author Philip Helger
 */
@ThreadSafe
public final class JAXBBuilderDefaultSettings
{
  private static final Logger LOGGER = LoggerFactory.getLogger (JAXBBuilderDefaultSettings.class);

  public static final boolean DEFAULT_USE_CONTEXT_CACHE = true;
  public static final ValidationEventHandler DEFAULT_VALIDATION_EVENT_HANDLER = LoggingValidationEventHandler.DEFAULT_INSTANCE;
  public static final boolean DEFAULT_FORMATTED_OUTPUT = false;
  public static final Charset DEFAULT_CHARSET = XMLWriterSettings.DEFAULT_XML_CHARSET_OBJ;
  public static final boolean DEFAULT_USE_SCHEMA = true;

  private static final SimpleReadWriteLock RW_LOCK = new SimpleReadWriteLock ();
  @GuardedBy ("RW_LOCK")
  private static boolean s_bUseContextCache = DEFAULT_USE_CONTEXT_CACHE;
  @GuardedBy ("RW_LOCK")
  private static ValidationEventHandler s_aEventHandler = DEFAULT_VALIDATION_EVENT_HANDLER;
  @GuardedBy ("RW_LOCK")
  private static NamespaceContext s_aNamespaceContext;
  @GuardedBy ("RW_LOCK")
  private static boolean s_bFormattedOutput = DEFAULT_FORMATTED_OUTPUT;
  @GuardedBy ("RW_LOCK")
  private static Charset s_aCharset = DEFAULT_CHARSET;
  @GuardedBy ("RW_LOCK")
  private static String s_sIndentString;
  @GuardedBy ("RW_LOCK")
  private static boolean s_bUseSchema = DEFAULT_USE_SCHEMA;
  @GuardedBy ("RW_LOCK")
  private static String s_sSchemaLocation;
  @GuardedBy ("RW_LOCK")
  private static String s_sNoNamespaceSchemaLocation;

  private JAXBBuilderDefaultSettings ()
  {}

  /**
   * @return true if the JAXBContext cache should be used. Default
   *         is true.
   */
  public static boolean isDefaultUseContextCache ()
  {
    return RW_LOCK.readLockedBoolean ( () -> s_bUseContextCache);
  }

  /**
   * Enable or disable the usage of the JAXBContext cache. For performance
   * reasons it is recommended to enable it. By default it is enabled.
   *
   * @param bUseContextCache
   *        true to enable it, false to disable it.
   */
  public static void setDefaultUseContextCache (final boolean bUseContextCache)
  {
    LOGGER.info ("The default JAXB Context Cache is now " + (bUseContextCache ? "enabled" : "disabled"));
    RW_LOCK.writeLocked ( () -> s_bUseContextCache = bUseContextCache);
  }

  /**
   * @return The current default validation event handler. May be
   *         null to indicate that no global validation event
   *         handler is defined, and the default validation handler is used.
   */
  @Nullable
  public static ValidationEventHandler getDefaultValidationEventHandler ()
  {
    return RW_LOCK.readLockedGet ( () -> s_aEventHandler);
  }

  /**
   * Set a global event handler that should be passed to all read/write actions.
   * If no global validation handler is defined, a default logging event handler
   * is used.
   *
   * @param aEventHandler
   *        The new default event handler. May be null to indicate,
   *        that the default handler should be used.
   */
  public static void setDefaultValidationEventHandler (@Nullable final ValidationEventHandler aEventHandler)
  {
    LOGGER.info ("The default JAXB Validation Event Handler is now " + aEventHandler);
    RW_LOCK.writeLocked ( () -> s_aEventHandler = aEventHandler);
  }

  /**
   * @return The special JAXB namespace context to be used. null by
   *         default.
   */
  @Nullable
  public static NamespaceContext getDefaultNamespaceContext ()
  {
    return RW_LOCK.readLockedGet ( () -> s_aNamespaceContext);
  }

  /**
   * Set the default namespace context (prefix to namespace URL mapping) to be
   * used.
   *
   * @param aNamespaceContext
   *        The namespace context to be used by default. May be
   *        null.
   */
  public static void setDefaultNamespaceContext (@Nullable final NamespaceContext aNamespaceContext)
  {
    LOGGER.info ("The default JAXB XML Namespace Context is now " + aNamespaceContext);
    RW_LOCK.writeLocked ( () -> s_aNamespaceContext = aNamespaceContext);
  }

  /**
   * @return true if the JAXB output should be formatted. Only for
   *         writers. Default is false. The JDK implementation does
   *         not format by default.
   */
  public static boolean isDefaultFormattedOutput ()
  {
    return RW_LOCK.readLockedBoolean ( () -> s_bFormattedOutput);
  }

  /**
   * Enable or disable the formatting of the output.
   *
   * @param bFormattedOutput
   *        true to enable it, false to disable it.
   */
  public static void setDefaultFormattedOutput (final boolean bFormattedOutput)
  {
    LOGGER.info ("The default JAXB XML output is now " + (bFormattedOutput ? "formatted" : "unformatted"));
    RW_LOCK.writeLocked ( () -> s_bFormattedOutput = bFormattedOutput);
  }

  /**
   * @return The special JAXB Charset to be used for writing. null
   *         by default. The JDK implementation uses UTF-8 by default.
   */
  @Nullable
  public static Charset getDefaultCharset ()
  {
    return RW_LOCK.readLockedGet ( () -> s_aCharset);
  }

  /**
   * Set the default charset to be used for writing JAXB objects.
   *
   * @param aCharset
   *        The charset to be used by default. May be null.
   */
  public static void setDefaultCharset (@Nullable final Charset aCharset)
  {
    LOGGER.info ("The default JAXB Charset is now " + (aCharset == null ? "null" : "'" + aCharset.name () + "'"));
    RW_LOCK.writeLocked ( () -> s_aCharset = aCharset);
  }

  /**
   * @return The JAXB indentation string to be used for writing.
   *         null by default. Only used when formatted output is
   *         used. The JDK implementation uses 4 spaces by default.
   */
  @Nullable
  public static String getDefaultIndentString ()
  {
    return RW_LOCK.readLockedGet ( () -> s_sIndentString);
  }

  @Nullable
  private static String _getNice (@Nullable final String s)
  {
    if (s == null)
      return null;
    final char [] aChars = s.toCharArray ();
    if (aChars.length == 0)
      return "";
    final StringBuilder ret = new StringBuilder (aChars.length * 3);
    for (final char c : aChars)
      if (c == '\f')
        ret.append ("\\f");
      else
        if (c == '\n')
          ret.append ("\\n");
        else
          if (c == '\r')
            ret.append ("\\r");
          else
            if (c == '\t')
              ret.append ("\\t");
            else
              ret.append (c);
    return ret.toString ();
  }

  /**
   * Set the default indent string to be used for writing JAXB objects.
   *
   * @param sIndentString
   *        The indent string to be used by default. May be null.
   */
  public static void setDefaultIndentString (@Nullable final String sIndentString)
  {
    LOGGER.info ("The default JAXB Indent String is now '" + _getNice (sIndentString) + "'");
    RW_LOCK.writeLocked ( () -> s_sIndentString = sIndentString);
  }

  /**
   * @return true if an eventually configured XML Schema should be
   *         used, false to explicitly disable the usage of XML
   *         Schema.
   * @since 11.0.3
   */
  public static boolean isDefaultUseSchema ()
  {
    return RW_LOCK.readLockedBoolean ( () -> s_bUseSchema);
  }

  /**
   * Enable or disable the usage of an eventually configured XML Schema.
   *
   * @param bUseSchema
   *        true to use an XML Schema, false to not
   *        use it.
   * @since 11.0.3
   */
  public static void setDefaultUseSchema (final boolean bUseSchema)
  {
    LOGGER.info ("The default JAXB XML Schema usage is now " + (bUseSchema ? "enabled" : "disabled"));
    RW_LOCK.writeLocked ( () -> s_bUseSchema = bUseSchema);
  }

  /**
   * @return The JAXB schema location to be used for writing. null
   *         by default.
   * @since 8.6.0
   */
  @Nullable
  public static String getDefaultSchemaLocation ()
  {
    return RW_LOCK.readLockedGet ( () -> s_sSchemaLocation);
  }

  /**
   * Set the schema location to be used for writing JAXB objects.
   *
   * @param sSchemaLocation
   *        The schema location to be used by default. May be null.
   * @since 8.6.0
   */
  public static void setDefaultSchemaLocation (@Nullable final String sSchemaLocation)
  {
    LOGGER.info ("The default JAXB XML Schema Location is now " +
                 (sSchemaLocation == null ? "null" : "'" + sSchemaLocation + "'"));
    RW_LOCK.writeLocked ( () -> s_sSchemaLocation = sSchemaLocation);
  }

  /**
   * @return The JAXB no namespace schema location to be used for writing.
   *         null by default.
   * @since 9.0.0
   */
  @Nullable
  public static String getDefaultNoNamespaceSchemaLocation ()
  {
    return RW_LOCK.readLockedGet ( () -> s_sNoNamespaceSchemaLocation);
  }

  /**
   * Set the no namespace schema location to be used for writing JAXB objects.
   *
   * @param sNoNamespaceSchemaLocation
   *        The no namespace schema location to be used by default. May be
   *        null.
   * @since 9.0.0
   */
  public static void setDefaultNoNamespaceSchemaLocation (@Nullable final String sNoNamespaceSchemaLocation)
  {
    LOGGER.info ("The default JAXB XML Schema No-Namespace Schema Location is now " +
                 (sNoNamespaceSchemaLocation == null ? "null" : "'" + sNoNamespaceSchemaLocation + "'"));
    RW_LOCK.writeLocked ( () -> s_sNoNamespaceSchemaLocation = sNoNamespaceSchemaLocation);
  }
}