* Expressions in the form of {@code ${property.key:default-value}} can be used for the values. If the property key is * prefixed with {@code sys.} a {@linkplain System#getProperty(String) system property} will be used. If the key is * prefixed with {@code env.} an {@linkplain System#getenv(String) environment variable} will be used. In all other cases * the {@code org.jboss.logging.tools.expressionProperties} processor argument is used to specify the path the properties * file which contains the values for the expressions. *
* * @author James R. Perkins * @since 1.2 */ @Target(TYPE) @Retention(CLASS) @Documented public @interface BaseUrl { /** * The base URL used for links to resolution documentation on reports. This can be a fully qualified URL or a * relative URL. * * @return the base URL */ String value(); } jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations/Cause.java 0000664 0000000 0000000 00000002336 13565604617 0033255 0 ustar 00root root 0000000 0000000 /* * JBoss, Home of Professional Open Source. * * Copyright 2015 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.PARAMETER; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; /** * Mark a parameter as being the "exception cause" parameter rather than a positional format parameter. * * @author David M. Lloyd */ @Retention(CLASS) @Target(PARAMETER) @Documented public @interface Cause { } ConstructType.java 0000664 0000000 0000000 00000003125 13565604617 0034761 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations /* * JBoss, Home of Professional Open Source. * * Copyright 2015 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.METHOD; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; /** * Indicates the value of this annotation should be constructed and returned. This does not change the return type of * the method. ** This annotation is only allowed on bundle messages that have a throwable return type. The value must be assignable * to the return type. *
* * @author James R. Perkins * @since 2.0.0 */ @Retention(CLASS) @Target(METHOD) @Documented public @interface ConstructType { /** * The actual type that should be constructed for the return type. * * @return the class to construct */ Class value(); } jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations/Field.java 0000664 0000000 0000000 00000007327 13565604617 0033245 0 ustar 00root root 0000000 0000000 /* * JBoss, Home of Professional Open Source. * * Copyright 2015 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.METHOD; import static java.lang.annotation.ElementType.PARAMETER; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Repeatable; import java.lang.annotation.Retention; import java.lang.annotation.Target; /** * Indicate that a method parameter value should be applied to a field on the resultant exception object. ** If this annotation is placed on a method the {@linkplain #name() name} attribute becomes a required parameter and one * default attribute needs to be set. The value of the default attribute is used to set the filed on the resultant * exception object. *
* * @author David M. Lloyd * @author James R. Perkins */ @Retention(CLASS) @Target({PARAMETER, METHOD}) @Repeatable(Fields.class) @Documented public @interface Field { /** * The field name. If not specified, the parameter name is assumed to be the field name. ** This becomes a required attrubyte if this annotation is present on a method. *
* * @return the field name */ String name() default ""; /** * The default {@code boolean} value if this annotation is used on a method. * * @return the default value to use */ boolean booleanValue() default false; /** * The default boolean value if this annotation is used on a method. * * @return the default value to use */ byte byteValue() default 0x00; /** * The default {@code byte} value if this annotation is used on a method. * * @return the default value to use */ char charValue() default 0x00; /** * The default {@link Class} value if this annotation is used on a method. * * @return the default value to use */ Class classValue() default Object.class; /** * The default {@code double} value if this annotation is used on a method. * * @return the default value to use */ double doubleValue() default 0.0d; /** * The default {@code float} value if this annotation is used on a method. * * @return the default value to use */ float floatValue() default 0.0f; /** * The default {@code int} value if this annotation is used on a method. * * @return the default value to use */ int intValue() default 0; /** * The default {@code long} value if this annotation is used on a method. * * @return the default value to use */ long longValue() default 0L; /** * The default {@code short} value if this annotation is used on a method. * * @return the default value to use */ short shortValue() default 0; /** * The default {@link String} value if this annotation is used on a method. * * @return the default value to use */ String stringValue() default ""; } jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations/Fields.java 0000664 0000000 0000000 00000002642 13565604617 0033423 0 ustar 00root root 0000000 0000000 /* * JBoss, Home of Professional Open Source. * * Copyright 2016 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.METHOD; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; /** * Defines the default field properties to use on the resultant exception object. * * @author James R. Perkins */ @Retention(CLASS) @Target(METHOD) @Documented public @interface Fields { /** * The fields to use on the resultant exception object. Note that the {@link Field#name() name} attribute is * required for these annotations. * * @return the fields */ Field[] value(); } FormatWith.java 0000664 0000000 0000000 00000003417 13565604617 0034223 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations /* * JBoss, Home of Professional Open Source. * * Copyright 2015 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.PARAMETER; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; /** * Indicate that the given parameter should be wrapped with a formatting object of the given class. The class * must have a one-argument constructor which unambiguously accepts a value of this parameter's type. The resultant * object will be passed in as a parameter to the underlying format type; thus its {@link Object#toString() toString()} * method will be invoked (or, if the format style is {@link Message.Format#PRINTF PRINTF}, the object may implement * {@link java.util.Formattable Formattable} to get extra functionality). * * @author David M. Lloyd */ @Target(PARAMETER) @Retention(CLASS) @Documented public @interface FormatWith { /** * The class of the formatting object to use. * * @return the class */ Class value(); } LogMessage.java 0000664 0000000 0000000 00000003251 13565604617 0034161 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations /* * JBoss, Home of Professional Open Source. * * Copyright 2015 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.METHOD; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; import org.jboss.logging.Logger; /** * A typed logger method. Indicates that this method will log the associated {@link Message} to the logger system, as * opposed to being a simple message lookup. * * @author David M. Lloyd */ @Retention(CLASS) @Target(METHOD) @Documented public @interface LogMessage { /** * The log level at which this message should be logged. Defaults to {@code INFO}. * * @return the log level */ Logger.Level level() default Logger.Level.INFO; /** * The logging class name to use for this message, if any. * * @return the logging class name */ Class loggingClass() default Void.class; } LoggingClass.java 0000664 0000000 0000000 00000002371 13565604617 0034511 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations /* * JBoss, Home of Professional Open Source. * * Copyright 2015 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.PARAMETER; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; /** * Mark a parameter as specifying the name of the logging class to use. The parameter * may have a type of {@link Class}. * * @author David M. Lloyd */ @Retention(CLASS) @Target(PARAMETER) @Documented public @interface LoggingClass { } jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations/Message.java0000664 0000000 0000000 00000005632 13565604617 0033603 0 ustar 00root root 0000000 0000000 /* * JBoss, Home of Professional Open Source. * * Copyright 2015 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.METHOD; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; /** * Assigns a message string to a resource method. The method arguments are used to supply the positional parameter * values for the method. * * @author David M. Lloyd */ @Target(METHOD) @Retention(CLASS) @Documented public @interface Message { /** * Indicates that this message has no ID. */ int NONE = 0; /** * Indicates that this message should inherit the ID from another message with the same name. */ int INHERIT = -1; /** * The message ID number. Only one message with a given name may specify an ID other than {@link #INHERIT}. * * @return the message ID number */ int id() default INHERIT; /** * The default format string of this message. ** Expressions in the form of {@code ${property.key:default-value}} can be used for the value. If the property key is * prefixed with {@code sys.} a {@linkplain System#getProperty(String) system property} will be used. If the key is * prefixed with {@code env.} an {@linkplain System#getenv(String) environment variable} will be used. In all other cases * the {@code org.jboss.logging.tools.expressionProperties} processor argument is used to specify the path the properties * file which contains the values for the expressions. *
* * @return the format string */ String value(); /** * The format type of this method (defaults to {@link Format#PRINTF}). * * @return the format type */ Format format() default Format.PRINTF; /** * The possible format types. */ enum Format { /** * A {@link java.util.Formatter}-type format string. */ PRINTF, /** * A {@link java.text.MessageFormat}-type format string. */ MESSAGE_FORMAT, /** * Indicates the message should not be formatted. */ NO_FORMAT, } } MessageBundle.java 0000664 0000000 0000000 00000005060 13565604617 0034651 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations /* * JBoss, Home of Professional Open Source. * * Copyright 2015 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.TYPE; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; import java.util.Locale; /** * Signify that an interface is a message bundle interface. * * @author David M. Lloyd */ @Target(TYPE) @Retention(CLASS) @Documented public @interface MessageBundle { /** * Get the project code for messages that have an associated code. If no project code is associated * with this bundle, specify {@code ""} (the empty string). * * @return the project code */ String projectCode(); /** * The length of the padding used for each id in the message bundle. For example given the default padding length * of 6 and a message with an id of 100 would result would be {@code "000100"}. * * Valid values a range of 3 to 8. Any value less than 0 turns off padding. Any other value will result in an error * being produced. * * @return the length the id should be padded */ int length() default 6; /** * Specifies the {@linkplain Locale locale} for formatting bundle messages. This is only used in the super * implementation. Subclasses will define their own locale to use based on the name of the resource bundle at * compile time. ** An empty string will default to {@link Locale#ROOT}. *
** A non-empty string will be parsed by the {@link Locale#forLanguageTag(String)}. This uses the * IETF BCP 47 format. *
* * @return the default locale message bundles should use for formatting messages */ String rootLocale() default ""; } MessageLogger.java 0000664 0000000 0000000 00000005436 13565604617 0034666 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations /* * JBoss, Home of Professional Open Source. * * Copyright 2015 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.TYPE; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; import java.util.Locale; /** * Signify that an interface is a typed logger interface. A message logger interface may optionally extend other * message logger interfaces and message bundle interfaces (see {@link org.jboss.logging.annotations.MessageBundle}, as * well as the {@link org.jboss.logging.BasicLogger} interface. * * @author David M. Lloyd */ @Retention(CLASS) @Target(TYPE) @Documented public @interface MessageLogger { /** * Get the project code for messages that have an associated code. If no project code is associated * with this logger, specify {@code ""} (the empty string). * * @return the project code */ String projectCode(); /** * The length of the padding used for each id in the message bundle. For example given the default padding length * of 6 and a message with an id of 100 would result would be {@code "000100"}. * * Valid values a range of 3 to 8. Any value less than 0 turns off padding. Any other value will result in an error * being produced. * * @return the length the id should be padded */ int length() default 6; /** * Specifies the {@linkplain Locale locale} for formatting bundle messages. This is only used in the super * implementation. Subclasses will define their own locale to use based on the name of the resource bundle at * compile time. ** An empty string will default to {@link Locale#ROOT}. *
** A non-empty string will be parsed by the {@link Locale#forLanguageTag(String)}. This uses the * IETF BCP 47 format. *
* * @return the default locale message bundles should use for formatting messages */ String rootLocale() default ""; } jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations/Once.java 0000664 0000000 0000000 00000002674 13565604617 0033106 0 ustar 00root root 0000000 0000000 /* * JBoss, Home of Professional Open Source. * * Copyright 2015 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.METHOD; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; /** * Indicates a message should only be logged once. ** Methods that use this annotation must be {@linkplain org.jboss.logging.annotations.LogMessage logger methods}. Overloaded * methods also annotated with {@code @Once} will inherit the same check only logging the message from the first * overloaded method invoked. *
* * @author James R. Perkins */ @Target(METHOD) @Retention(CLASS) @Documented public @interface Once { } jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations/Param.java 0000664 0000000 0000000 00000003454 13565604617 0033257 0 ustar 00root root 0000000 0000000 /* * JBoss, Home of Professional Open Source. * * Copyright 2015 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.PARAMETER; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; /** * Identifies a parameter is to be used for constructing an exception and excluded from the formatting of the message. * * Parameters will be order-matched first, then type-matched to resolve ambiguity. If a match fails an error should * occur. * * The {@link #value()} option will allow an optional class to be specified which will have to match the exact type of * the parameter in question, to enable unambiguous resolution. The value must be the fully qualified class name. * * @author James R. Perkins */ @Target(PARAMETER) @Retention(CLASS) @Documented public @interface Param { /** * Defines an exact class the parameter must match for unambiguous resolution. * * @return the class the parameter must match. */ Class value() default Object.class; } jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations/Pos.java 0000664 0000000 0000000 00000002730 13565604617 0032754 0 ustar 00root root 0000000 0000000 /* * JBoss, Home of Professional Open Source. * * Copyright 2015 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.PARAMETER; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; /** * @author James R. Perkins * @since 1.1.0 */ @Retention(CLASS) @Target(PARAMETER) @Documented public @interface Pos { /** * The positions the value should be used at. * * @return an array of the positions for the parameter */ int[] value(); /** * The transform types used on the parameter. * * @return an array of the transformer types * * @see Transform */ Transform[] transform() default {}; } Producer.java 0000664 0000000 0000000 00000005326 13565604617 0033723 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations /* * JBoss, Home of Professional Open Source. * * Copyright 2017 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.PARAMETER; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; /** * Identifies a parameter has the ability to produce a {@link Throwable} or a super type of a {@code Throwable}. The * parameter type must be a {@link java.util.function.Function} or a {@link java.util.function.BiFunction}. ** For a {@link java.util.function.Function} the input parameter must be a {@link String} which will be the message * associated with the method. The result type must {@link Throwable} or a super type of a {@code Throwable}. *
* ** For a {@link java.util.function.BiFunction} one of the input parameters must be a {@link String} which will be the * message associated with the method. The other input parameter must be a {@link Throwable} or a super type of a * {@code Throwable} and must be assignable from the parameter annotated with {@link Cause}. The result type must * {@link Throwable} or a super type of a {@code Throwable}. *
* *
* Example
*
*
*
* @Message("The operation failed due to %s")
*
*
* Example Usage
*
*
*
* throw Bundle.MESSAGES.operationFailed(IllegalArgumentException::new, "start");
*
* throw Bundle.MESSAGES.operationFailed(IllegalStateException::new, cause, "start");
*
*
*
* If this annotation is placed on a method the {@linkplain #name() name} attribute becomes a required parameter and one * default attribute needs to be set. The value of the default attribute is used to set the property on the resultant * exception object. *
* * @author David M. Lloyd * @author James R. Perkins */ @Retention(CLASS) @Target({PARAMETER, METHOD}) @Repeatable(Properties.class) @Documented public @interface Property { /** * The property name. If not specified, the parameter name is assumed to be the property name. ** This becomes a required attribute if this annotation is present on a method. *
* * @return the property name */ String name() default ""; /** * The default {@code boolean} value if this annotation is used on a method. * * @return the default value to use */ boolean booleanValue() default false; /** * The default boolean value if this annotation is used on a method. * * @return the default value to use */ byte byteValue() default 0x00; /** * The default {@code byte} value if this annotation is used on a method. * * @return the default value to use */ char charValue() default 0x00; /** * The default {@link Class} value if this annotation is used on a method. * * @return the default value to use */ Class classValue() default Object.class; /** * The default {@code double} value if this annotation is used on a method. * * @return the default value to use */ double doubleValue() default 0.0d; /** * The default {@code float} value if this annotation is used on a method. * * @return the default value to use */ float floatValue() default 0.0f; /** * The default {@code int} value if this annotation is used on a method. * * @return the default value to use */ int intValue() default 0; /** * The default {@code long} value if this annotation is used on a method. * * @return the default value to use */ long longValue() default 0L; /** * The default {@code short} value if this annotation is used on a method. * * @return the default value to use */ short shortValue() default 0; /** * The default {@link String} value if this annotation is used on a method. * * @return the default value to use */ String stringValue() default ""; } ResolutionDoc.java 0000664 0000000 0000000 00000010355 13565604617 0034727 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations /* * JBoss, Home of Professional Open Source. * * Copyright 2017 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.METHOD; import static java.lang.annotation.ElementType.TYPE; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; /** * Allows a link to be created for messages on a report which contain a possible resolution to the issue reported . If * the method does not include an {@linkplain Message#id() id} no link will be created for the report unless a * {@link #path()} is defined. * ** The rules for building the URL are as follows: *
* If placed on a type links will be created for all methods on the type. *
* ** Do note that the processor does not validate the resolution document exists. It simply attempts to create links to * the resolution document. *
** Expressions in the form of {@code ${property.key:default-value}} can be used for the values with the exception of the * {@link #skip() skip} attribute. If the property key is prefixed with {@code sys.} a * {@linkplain System#getProperty(String) system property} will be used. If the key is prefixed with {@code env.} an * {@linkplain System#getenv(String) environment variable} will be used. In all other cases the * {@code org.jboss.logging.tools.expressionProperties} processor argument is used to specify the path the properties * file which contains the values for the expressions. *
* * @author James R. Perkins * @since 1.2 */ @Target({METHOD, TYPE}) @Retention(CLASS) @Documented public @interface ResolutionDoc { /** * The URL, fully qualified or relative, to use for the resolution document. If defined this will override the value * of the {@link BaseUrl} if the annotation is used. * * @return the URL or an empty string */ String url() default ""; /** * The path to the resolution document. If left undefined this will default to the message id. * * @return the path to the resolution document */ String path() default ""; /** * The suffix to append to the path. If left undefined this will default to the extension for the report type. For * example if the report type is {@code xml} the default suffix would be {@code .xml}. * * @return the suffix for the resolution document */ String suffix() default ""; /** * Allows the creation of a link to be skipped. * * @return {@code true} if creating the link should be skipped */ boolean skip() default false; } Signature.java 0000664 0000000 0000000 00000006675 13565604617 0034111 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations /* * JBoss, Home of Professional Open Source. * * Copyright 2016 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.METHOD; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; /** * Specifies the exact signature to use when creating a {@link Throwable} return type. * *
* Given the following exception and message bundle interface method the {@code InvalidIntValueException(final RuntimeException cause, final String msg, final int value)}
* constructor would be used.
*
*
*
*
*
* public class InvalidIntValueException extends RuntimeException {
* private final RuntimeException causeAsRuntime;
* private final int value;
* public InvalidIntValueException(final Throwable cause, final String msg, final int value) {
* super(msg, cause);
* causeAsRuntime = new RuntimeException(cause);
* this.value = value;
* }
*
* public InvalidIntValueException(final RuntimeException cause, final String msg, final int value) {
* super(msg, cause);
* causeAsRuntime = cause;
* this.value = value;
* }
* public InvalidIntValueException(final RuntimeException cause, final String msg, final Integer value) {
* super(msg, cause);
* causeAsRuntime = cause;
* this.value = value;
* }
* }
*
*
*
*
* @Message("Invalid value %d")
* @Signature(causeIndex = 0, messageIndex = 1, value = {RuntimeException.class, String.class, int.class}
* InvalidIntValueException invalidValue(@Cause RuntimeException cause, @Param int value);
*
*
* The annotated parameter can be a single {@linkplain Throwable throwable type}, an array of * {@linkplain Throwable throwable types} or a {@linkplain java.util.Collection collection} of * {@linkplain Throwable throwable types}. Note this is only allowed on message bundle methods that return a * {@linkplain Throwable throwable type}. *
* * @author James R. Perkins */ @Retention(CLASS) @Target(PARAMETER) @Documented public @interface Suppressed { } Transform.java 0000664 0000000 0000000 00000005574 13565604617 0034120 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations /* * JBoss, Home of Professional Open Source. * * Copyright 2015 Red Hat, Inc., and individual contributors * as indicated by the @author tags. * * 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 org.jboss.logging.annotations; import static java.lang.annotation.ElementType.PARAMETER; import static java.lang.annotation.RetentionPolicy.CLASS; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; /** * Indicate the given parameter should be transformed in each of the {@link org.jboss.logging.annotations.Transform.TransformType transform types} * provided. The parameter cannot be a primitive type. * * For the {@link TransformType#SIZE} type, the object must be a {@link String}, a {@link java.util.Collection}, a * {@link java.util.Map} or an array. * * The type {@link TransformType#GET_CLASS} can be used with {@link TransformType#HASH_CODE} or {@link * TransformType#IDENTITY_HASH_CODE}. The type {@link TransformType#SIZE} must be used on it's own. * * @author James R. Perkins * @since 1.1.0 */ @Retention(CLASS) @Target(PARAMETER) @Documented public @interface Transform { /** * The transform type */ public enum TransformType { /** * Gets the class of the object object passed, {@link Object#getClass()}. */ GET_CLASS, /** * Gets the hash code of the object, {@link Object#hashCode()}. */ HASH_CODE, /** * Gets the identity hash code of the object, {@link System#identityHashCode(Object)}. */ IDENTITY_HASH_CODE, /** * Gets the size or length of a {@link String}, {@link java.util.Collection}, {@link java.util.Map} or array. */ SIZE, } /** * The transform types used on the parameter. * * Valid combinations: *
*
* @MessageLogger(projectCode = "EXAMPLE")
* @ValidIdRange(min = 100, max = 200)
* public interface ExampleLogger {
*
* @LogMessage
* @Message(id = 100, value = "Example message")
* void example();
* }
*
*
*
* @author James R. Perkins
*/
@Target(TYPE)
@Retention(CLASS)
@Documented
public @interface ValidIdRange {
/**
* The minimum id allowed in the {@link org.jboss.logging.annotations.Message#id() message id}. Both {@link
* Message#INHERIT} and {@link Message#NONE} are ignored when validating.
*
* @return the minimum id allowed
*/
int min() default 1;
/**
* The maximum id allowed in the {@link org.jboss.logging.annotations.Message#id() message id}. Both {@link
* Message#INHERIT} and {@link Message#NONE} are ignored when validating.
*
* @return the maximum id allowed
*/
int max() default 999999;
}
ValidIdRanges.java 0000664 0000000 0000000 00000002363 13565604617 0034612 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/annotations/src/main/java/org/jboss/logging/annotations /*
* JBoss, Home of Professional Open Source.
*
* Copyright 2015 Red Hat, Inc., and individual contributors
* as indicated by the @author tags.
*
* 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 org.jboss.logging.annotations;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.CLASS;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
/**
* @author James R. Perkins
*/
@Target(TYPE)
@Retention(CLASS)
@Documented
public @interface ValidIdRanges {
/**
* An array of valid id ranges.
*
* @return an array of valid id ranges
*/
ValidIdRange[] value();
}
jboss-logging-tools-2.2.1.Final/annotations/src/main/resources/ 0000775 0000000 0000000 00000000000 13565604617 0024545 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/annotations/src/main/resources/META-INF/ 0000775 0000000 0000000 00000000000 13565604617 0025705 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/annotations/src/main/resources/META-INF/LICENSE.txt 0000664 0000000 0000000 00000026135 13565604617 0027537 0 ustar 00root root 0000000 0000000
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
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. jboss-logging-tools-2.2.1.Final/docs/ 0000775 0000000 0000000 00000000000 13565604617 0017413 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/docs/apidocs/ 0000775 0000000 0000000 00000000000 13565604617 0021035 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/docs/apidocs/allclasses-frame.html 0000664 0000000 0000000 00000010365 13565604617 0025146 0 ustar 00root root 0000000 0000000
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/deprecated-list.html 0000664 0000000 0000000 00000007563 13565604617 0025007 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/help-doc.html 0000664 0000000 0000000 00000021342 13565604617 0023420 0 ustar 00root root 0000000 0000000Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain six categories:
Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
Each annotation type has its own separate page with the following sections:
Each enum has its own separate page with the following sections:
Each documented package, class and interface has its own Use page. This page describes what packages, classes, methods, constructors and fields use any part of the given class or package. Given a class or interface A, its Use page includes subclasses of A, fields declared as A, methods that return A, and methods and constructors with parameters of type A. You can access this page by first going to the package, class or interface, then clicking on the "Use" link in the navigation bar.
There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
These links take you to the next or previous class, interface, package, or related page.
These links show and hide the HTML frames. All pages are available with or without frames.
The All Classes link shows all classes and interfaces except non-static nested types.
Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class description.
The Constant Field Values page lists the static final fields and their values.
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/index-all.html 0000664 0000000 0000000 00000044106 13565604617 0023605 0 ustar 00root root 0000000 0000000Throwable or a super type of a Throwable.Throwable return type.transform types
provided.message id.Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/index.html 0000664 0000000 0000000 00000005450 13565604617 0023036 0 ustar 00root root 0000000 0000000@Target(value=TYPE) @Retention(value=CLASS) @Documented public @interface BaseUrl
Expressions in the form of ${property.key:default-value} can be used for the values. If the property key is
prefixed with sys. a system property will be used. If the key is
prefixed with env. an environment variable will be used. In all other cases
the org.jboss.logging.tools.expressionProperties processor argument is used to specify the path the properties
file which contains the values for the expressions.
public abstract String value
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/Cause.html 0000664 0000000 0000000 00000016015 13565604617 0030660 0 ustar 00root root 0000000 0000000@Retention(value=CLASS) @Target(value=PARAMETER) @Documented public @interface Cause
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/ConstructType.html 0000664 0000000 0000000 00000023344 13565604617 0032451 0 ustar 00root root 0000000 0000000@Retention(value=CLASS) @Target(value=METHOD) @Documented public @interface ConstructType
This annotation is only allowed on bundle messages that have a throwable return type. The value must be assignable to the return type.
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/Field.html 0000664 0000000 0000000 00000046247 13565604617 0030655 0 ustar 00root root 0000000 0000000@Retention(value=CLASS) @Target(value={PARAMETER,METHOD}) @Repeatable(value=Fields.class) @Documented public @interface Field
If this annotation is placed on a method the name attribute becomes a required parameter and one default attribute needs to be set. The value of the default attribute is used to set the filed on the resultant exception object.
| Modifier and Type | Optional Element and Description |
|---|---|
boolean |
booleanValue
The default
boolean value if this annotation is used on a method. |
byte |
byteValue
The default boolean value if this annotation is used on a method.
|
char |
charValue
The default
byte value if this annotation is used on a method. |
Class<?> |
classValue
The default
Class value if this annotation is used on a method. |
double |
doubleValue
The default
double value if this annotation is used on a method. |
float |
floatValue
The default
float value if this annotation is used on a method. |
int |
intValue
The default
int value if this annotation is used on a method. |
long |
longValue
The default
long value if this annotation is used on a method. |
String |
name
The field name.
|
short |
shortValue
The default
short value if this annotation is used on a method. |
String |
stringValue
The default
String value if this annotation is used on a method. |
public abstract String name
This becomes a required attrubyte if this annotation is present on a method.
public abstract boolean booleanValue
boolean value if this annotation is used on a method.public abstract byte byteValue
public abstract char charValue
byte value if this annotation is used on a method.public abstract double doubleValue
double value if this annotation is used on a method.public abstract float floatValue
float value if this annotation is used on a method.public abstract int intValue
int value if this annotation is used on a method.public abstract long longValue
long value if this annotation is used on a method.Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/Fields.html 0000664 0000000 0000000 00000022244 13565604617 0031027 0 ustar 00root root 0000000 0000000@Retention(value=CLASS) @Target(value=METHOD) @Documented public @interface Fields
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/FormatWith.html 0000664 0000000 0000000 00000023543 13565604617 0031710 0 ustar 00root root 0000000 0000000@Target(value=PARAMETER) @Retention(value=CLASS) @Documented public @interface FormatWith
toString()
method will be invoked (or, if the format style is PRINTF, the object may implement
Formattable to get extra functionality).public abstract Class<?> value
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/LogMessage.html 0000664 0000000 0000000 00000024376 13565604617 0031657 0 ustar 00root root 0000000 0000000@Retention(value=CLASS) @Target(value=METHOD) @Documented public @interface LogMessage
Message to the logger system, as
opposed to being a simple message lookup.| Modifier and Type | Optional Element and Description |
|---|---|
org.jboss.logging.Logger.Level |
level
The log level at which this message should be logged.
|
Class<?> |
loggingClass
The logging class name to use for this message, if any.
|
public abstract org.jboss.logging.Logger.Level level
INFO.public abstract Class<?> loggingClass
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/LoggingClass.html 0000664 0000000 0000000 00000016367 13565604617 0032206 0 ustar 00root root 0000000 0000000@Retention(value=CLASS) @Target(value=PARAMETER) @Documented public @interface LoggingClass
Class.Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/Message.Format.html 0000664 0000000 0000000 00000044374 13565604617 0032444 0 ustar 00root root 0000000 0000000public static enum Message.Format extends Enum<Message.Format>
| Enum Constant and Description |
|---|
MESSAGE_FORMAT
A
MessageFormat-type format string. |
NO_FORMAT
Indicates the message should not be formatted.
|
PRINTF
A
Formatter-type format string. |
| Modifier and Type | Method and Description |
|---|---|
static Message.Format |
valueOf(String name)
Returns the enum constant of this type with the specified name.
|
static Message.Format[] |
values()
Returns an array containing the constants of this enum type, in
the order they are declared.
|
public static final Message.Format PRINTF
Formatter-type format string.public static final Message.Format MESSAGE_FORMAT
MessageFormat-type format string.public static final Message.Format NO_FORMAT
public static Message.Format[] values()
for (Message.Format c : Message.Format.values()) System.out.println(c);
public static Message.Format valueOf(String name)
name - the name of the enum constant to be returned.IllegalArgumentException - if this enum type has no constant with the specified nameNullPointerException - if the argument is nullCopyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/Message.html 0000664 0000000 0000000 00000035454 13565604617 0031214 0 ustar 00root root 0000000 0000000@Target(value=METHOD) @Retention(value=CLASS) @Documented public @interface Message
| Modifier and Type | Fields and Description |
|---|---|
static int |
INHERIT
Indicates that this message should inherit the ID from another message with the same name.
|
static int |
NONE
Indicates that this message has no ID.
|
| Modifier and Type | Required Element and Description |
|---|---|
String |
value
The default format string of this message.
|
| Modifier and Type | Optional Element and Description |
|---|---|
Message.Format |
format
The format type of this method (defaults to
Message.Format.PRINTF). |
int |
id
The message ID number.
|
public static final int INHERIT
public abstract String value
Expressions in the form of ${property.key:default-value} can be used for the value. If the property key is
prefixed with sys. a system property will be used. If the key is
prefixed with env. an environment variable will be used. In all other cases
the org.jboss.logging.tools.expressionProperties processor argument is used to specify the path the properties
file which contains the values for the expressions.
public abstract int id
INHERIT.public abstract Message.Format format
Message.Format.PRINTF).Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/MessageBundle.html 0000664 0000000 0000000 00000032130 13565604617 0032332 0 ustar 00root root 0000000 0000000@Target(value=TYPE) @Retention(value=CLASS) @Documented public @interface MessageBundle
| Modifier and Type | Required Element and Description |
|---|---|
String |
projectCode
Get the project code for messages that have an associated code.
|
| Modifier and Type | Optional Element and Description |
|---|---|
int |
length
The length of the padding used for each id in the message bundle.
|
String |
rootLocale
Specifies the locale for formatting bundle messages.
|
public abstract String projectCode
"" (the empty string).public abstract int length
"000100".
Valid values a range of 3 to 8. Any value less than 0 turns off padding. Any other value will result in an error
being produced.public abstract String rootLocale
An empty string will default to Locale.ROOT.
A non-empty string will be parsed by the Locale.forLanguageTag(String). This uses the
IETF BCP 47 format.
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/MessageLogger.html 0000664 0000000 0000000 00000032623 13565604617 0032347 0 ustar 00root root 0000000 0000000@Retention(value=CLASS) @Target(value=TYPE) @Documented public @interface MessageLogger
MessageBundle, as
well as the BasicLogger interface.| Modifier and Type | Required Element and Description |
|---|---|
String |
projectCode
Get the project code for messages that have an associated code.
|
| Modifier and Type | Optional Element and Description |
|---|---|
int |
length
The length of the padding used for each id in the message bundle.
|
String |
rootLocale
Specifies the locale for formatting bundle messages.
|
public abstract String projectCode
"" (the empty string).public abstract int length
"000100".
Valid values a range of 3 to 8. Any value less than 0 turns off padding. Any other value will result in an error
being produced.public abstract String rootLocale
An empty string will default to Locale.ROOT.
A non-empty string will be parsed by the Locale.forLanguageTag(String). This uses the
IETF BCP 47 format.
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/Once.html 0000664 0000000 0000000 00000016436 13565604617 0030513 0 ustar 00root root 0000000 0000000@Target(value=METHOD) @Retention(value=CLASS) @Documented public @interface Once
Methods that use this annotation must be logger methods. Overloaded
methods also annotated with @Once will inherit the same check only logging the message from the first
overloaded method invoked.
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/Param.html 0000664 0000000 0000000 00000023205 13565604617 0030657 0 ustar 00root root 0000000 0000000@Target(value=PARAMETER) @Retention(value=CLASS) @Documented public @interface Param
value() option will allow an optional class to be specified which will have to match the exact type of
the parameter in question, to enable unambiguous resolution. The value must be the fully qualified class name.public abstract Class<?> value
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/Pos.html 0000664 0000000 0000000 00000025270 13565604617 0030364 0 ustar 00root root 0000000 0000000@Retention(value=CLASS) @Target(value=PARAMETER) @Documented public @interface Pos
| Modifier and Type | Required Element and Description |
|---|---|
int[] |
value
The positions the value should be used at.
|
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/Producer.html 0000664 0000000 0000000 00000023745 13565604617 0031413 0 ustar 00root root 0000000 0000000@Target(value=PARAMETER) @Retention(value=CLASS) @Documented public @interface Producer
Throwable or a super type of a Throwable. The
parameter type must be a Function or a BiFunction.
For a Function the input parameter must be a String which will be the message
associated with the method. The result type must Throwable or a super type of a Throwable.
For a BiFunction one of the input parameters must be a String which will be the
message associated with the method. The other input parameter must be a Throwable or a super type of a
Throwable and must be assignable from the parameter annotated with Cause. The result type must
Throwable or a super type of a Throwable.
Example
@Message("The operation failed due to %s")
Example Usage
throw Bundle.MESSAGES.operationFailed(IllegalArgumentException::new, "start");
throw Bundle.MESSAGES.operationFailed(IllegalStateException::new, cause, "start");
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/Properties.html 0000664 0000000 0000000 00000022353 13565604617 0031756 0 ustar 00root root 0000000 0000000@Retention(value=CLASS) @Target(value=METHOD) @Documented public @interface Properties
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/Property.html 0000664 0000000 0000000 00000046446 13565604617 0031457 0 ustar 00root root 0000000 0000000@Retention(value=CLASS) @Target(value={PARAMETER,METHOD}) @Repeatable(value=Properties.class) @Documented public @interface Property
If this annotation is placed on a method the name attribute becomes a required parameter and one default attribute needs to be set. The value of the default attribute is used to set the property on the resultant exception object.
| Modifier and Type | Optional Element and Description |
|---|---|
boolean |
booleanValue
The default
boolean value if this annotation is used on a method. |
byte |
byteValue
The default boolean value if this annotation is used on a method.
|
char |
charValue
The default
byte value if this annotation is used on a method. |
Class<?> |
classValue
The default
Class value if this annotation is used on a method. |
double |
doubleValue
The default
double value if this annotation is used on a method. |
float |
floatValue
The default
float value if this annotation is used on a method. |
int |
intValue
The default
int value if this annotation is used on a method. |
long |
longValue
The default
long value if this annotation is used on a method. |
String |
name
The property name.
|
short |
shortValue
The default
short value if this annotation is used on a method. |
String |
stringValue
The default
String value if this annotation is used on a method. |
public abstract String name
This becomes a required attribute if this annotation is present on a method.
public abstract boolean booleanValue
boolean value if this annotation is used on a method.public abstract byte byteValue
public abstract char charValue
byte value if this annotation is used on a method.public abstract double doubleValue
double value if this annotation is used on a method.public abstract float floatValue
float value if this annotation is used on a method.public abstract int intValue
int value if this annotation is used on a method.public abstract long longValue
long value if this annotation is used on a method.Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/ResolutionDoc.html 0000664 0000000 0000000 00000040264 13565604617 0032414 0 ustar 00root root 0000000 0000000@Target(value={METHOD,TYPE}) @Retention(value=CLASS) @Documented public @interface ResolutionDoc
path() is defined.
The rules for building the URL are as follows:
url: If left empty and the type is annotated with a BaseUrl the value for the
@BaseUrl will be used. If defined this will override the value of the BaseUrl. If neither are
defined the rules for the path() will be followed.path: If defined this will be the path appended to the url() or the value of the
BaseUrl. Note that neither url() nor BaseUrl are required. If the value is left
undefined the id (project code plus the message id) will be used for the path.suffix: The suffix to append to the path(). This is mostly useful if the path
is left undefined and a suffix should be appended to the messages id. If left undefined and the path()
is not defined, the suffix will be determined based on the report type.If placed on a type links will be created for all methods on the type.
Do note that the processor does not validate the resolution document exists. It simply attempts to create links to the resolution document.
Expressions in the form of ${property.key:default-value} can be used for the values with the exception of the
skip attribute. If the property key is prefixed with sys. a
system property will be used. If the key is prefixed with env. an
environment variable will be used. In all other cases the
org.jboss.logging.tools.expressionProperties processor argument is used to specify the path the properties
file which contains the values for the expressions.
| Modifier and Type | Optional Element and Description |
|---|---|
String |
path
The path to the resolution document.
|
boolean |
skip
Allows the creation of a link to be skipped.
|
String |
suffix
The suffix to append to the path.
|
String |
url
The URL, fully qualified or relative, to use for the resolution document.
|
public abstract String path
public abstract String suffix
xml the default suffix would be .xml.Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/Signature.html 0000664 0000000 0000000 00000033535 13565604617 0031567 0 ustar 00root root 0000000 0000000@Retention(value=CLASS) @Target(value=METHOD) @Documented public @interface Signature
Throwable return type.
Given the following exception and message bundle interface method the InvalidIntValueException(final RuntimeException cause, final String msg, final int value)
constructor would be used.
public class InvalidIntValueException extends RuntimeException {
private final RuntimeException causeAsRuntime;
private final int value;
public InvalidIntValueException(final Throwable cause, final String msg, final int value) {
super(msg, cause);
causeAsRuntime = new RuntimeException(cause);
this.value = value;
}
public InvalidIntValueException(final RuntimeException cause, final String msg, final int value) {
super(msg, cause);
causeAsRuntime = cause;
this.value = value;
}
public InvalidIntValueException(final RuntimeException cause, final String msg, final Integer value) {
super(msg, cause);
causeAsRuntime = cause;
this.value = value;
}
}
@Message("Invalid value %d")
@Signature(causeIndex = 0, messageIndex = 1, value = {RuntimeException.class, String.class, int.class}
InvalidIntValueException invalidValue(@Cause RuntimeException cause, @Param int value);
| Modifier and Type | Required Element and Description |
|---|---|
Class<?>[] |
value
An array of types matching the exact signature to use for the exception being created.
|
| Modifier and Type | Optional Element and Description |
|---|---|
int |
causeIndex
The index for the cause of the exception being created.
|
int |
messageIndex
The index for the message.
|
public abstract Class<?>[] value
public abstract int causeIndex
Cause annotation can still be used and the
Throwable.initCause(Throwable) will be used to initialize the cause of the exception.public abstract int messageIndex
Message.value(). This is a required
value defaulting to 0 which would be the first parameter.Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/Suppressed.html 0000664 0000000 0000000 00000020161 13565604617 0031752 0 ustar 00root root 0000000 0000000@Retention(value=CLASS) @Target(value=PARAMETER) @Documented public @interface Suppressed
The annotated parameter can be a single throwable type, an array of throwable types or a collection of throwable types. Note this is only allowed on message bundle methods that return a throwable type.
Copyright © 2019 JBoss by Red Hat. All rights reserved.
Transform.TransformType.html 0000664 0000000 0000000 00000051267 13565604617 0034340 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotationspublic static enum Transform.TransformType extends Enum<Transform.TransformType>
| Enum Constant and Description |
|---|
GET_CLASS
Gets the class of the object object passed,
Object.getClass(). |
HASH_CODE
Gets the hash code of the object,
Object.hashCode(). |
IDENTITY_HASH_CODE
Gets the identity hash code of the object,
System.identityHashCode(Object). |
SIZE
|
| Modifier and Type | Method and Description |
|---|---|
static Transform.TransformType |
valueOf(String name)
Returns the enum constant of this type with the specified name.
|
static Transform.TransformType[] |
values()
Returns an array containing the constants of this enum type, in
the order they are declared.
|
public static final Transform.TransformType GET_CLASS
Object.getClass().public static final Transform.TransformType HASH_CODE
Object.hashCode().public static final Transform.TransformType IDENTITY_HASH_CODE
System.identityHashCode(Object).public static final Transform.TransformType SIZE
public static Transform.TransformType[] values()
for (Transform.TransformType c : Transform.TransformType.values()) System.out.println(c);
public static Transform.TransformType valueOf(String name)
name - the name of the enum constant to be returned.IllegalArgumentException - if this enum type has no constant with the specified nameNullPointerException - if the argument is nullCopyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/Transform.html 0000664 0000000 0000000 00000027643 13565604617 0031604 0 ustar 00root root 0000000 0000000@Retention(value=CLASS) @Target(value=PARAMETER) @Documented public @interface Transform
transform types
provided. The parameter cannot be a primitive type.
For the Transform.TransformType.SIZE type, the object must be a String, a Collection, a
Map or an array.
The type Transform.TransformType.GET_CLASS can be used with Transform.TransformType.HASH_CODE or Transform.TransformType.IDENTITY_HASH_CODE. The type Transform.TransformType.SIZE must be used on it's own.| Modifier and Type | Required Element and Description |
|---|---|
Transform.TransformType[] |
value
The transform types used on the parameter.
|
public abstract Transform.TransformType[] value
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/ValidIdRange.html 0000664 0000000 0000000 00000026271 13565604617 0032116 0 ustar 00root root 0000000 0000000@Target(value=TYPE) @Retention(value=CLASS) @Documented public @interface ValidIdRange
message id. Both Message.INHERIT and Message.NONE are ignored when validating.
Note: Message id's from inherited interfaces are not validated within the range provided. Super interfaces
would need their own annotation for range validation.
@MessageLogger(projectCode = "EXAMPLE")
@ValidIdRange(min = 100, max = 200)
public interface ExampleLogger {
@LogMessage
@Message(id = 100, value = "Example message")
void example();
}
| Modifier and Type | Optional Element and Description |
|---|---|
int |
max
The maximum id allowed in the
message id. |
int |
min
The minimum id allowed in the
message id. |
public abstract int min
message id. Both Message.INHERIT and Message.NONE are ignored when validating.public abstract int max
message id. Both Message.INHERIT and Message.NONE are ignored when validating.Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/ValidIdRanges.html 0000664 0000000 0000000 00000021303 13565604617 0032270 0 ustar 00root root 0000000 0000000@Target(value=TYPE) @Retention(value=CLASS) @Documented public @interface ValidIdRanges
| Modifier and Type | Required Element and Description |
|---|---|
ValidIdRange[] |
value
An array of valid id ranges.
|
public abstract ValidIdRange[] value
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/ 0000775 0000000 0000000 00000000000 13565604617 0030626 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/BaseUrl.html 0000664 0000000 0000000 00000011106 13565604617 0033050 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/Cause.html 0000664 0000000 0000000 00000011060 13565604617 0032552 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
ConstructType.html 0000664 0000000 0000000 00000011210 13565604617 0034256 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-useCopyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/Field.html 0000664 0000000 0000000 00000011060 13565604617 0032535 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/Fields.html 0000664 0000000 0000000 00000011073 13565604617 0032724 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/FormatWith.html0000664 0000000 0000000 00000011147 13565604617 0033604 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/LogMessage.html0000664 0000000 0000000 00000011147 13565604617 0033546 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
LoggingClass.html 0000664 0000000 0000000 00000011175 13565604617 0034016 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-useCopyright © 2019 JBoss by Red Hat. All rights reserved.
Message.Format.html 0000664 0000000 0000000 00000015527 13565604617 0034262 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use| Modifier and Type | Method and Description |
|---|---|
static Message.Format |
Message.Format.valueOf(String name)
Returns the enum constant of this type with the specified name.
|
static Message.Format[] |
Message.Format.values()
Returns an array containing the constants of this enum type, in
the order they are declared.
|
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/Message.html 0000664 0000000 0000000 00000011106 13565604617 0033077 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
MessageBundle.html 0000664 0000000 0000000 00000011210 13565604617 0034146 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-useCopyright © 2019 JBoss by Red Hat. All rights reserved.
MessageLogger.html 0000664 0000000 0000000 00000011210 13565604617 0034154 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-useCopyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/Once.html 0000664 0000000 0000000 00000011045 13565604617 0032401 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/Param.html 0000664 0000000 0000000 00000011060 13565604617 0032552 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/Pos.html 0000664 0000000 0000000 00000011032 13565604617 0032252 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/Producer.html 0000664 0000000 0000000 00000011121 13565604617 0033273 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/Properties.html0000664 0000000 0000000 00000011147 13565604617 0033654 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/Property.html 0000664 0000000 0000000 00000011121 13565604617 0033334 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
ResolutionDoc.html 0000664 0000000 0000000 00000011210 13565604617 0034221 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-useCopyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/Signature.html 0000664 0000000 0000000 00000011134 13565604617 0033455 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/Suppressed.html0000664 0000000 0000000 00000011147 13565604617 0033655 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
Transform.TransformType.html 0000664 0000000 0000000 00000016035 13565604617 0036231 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use| Modifier and Type | Method and Description |
|---|---|
static Transform.TransformType |
Transform.TransformType.valueOf(String name)
Returns the enum constant of this type with the specified name.
|
static Transform.TransformType[] |
Transform.TransformType.values()
Returns an array containing the constants of this enum type, in
the order they are declared.
|
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-use/Transform.html 0000664 0000000 0000000 00000011134 13565604617 0033467 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
ValidIdRange.html 0000664 0000000 0000000 00000011175 13565604617 0033733 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-useCopyright © 2019 JBoss by Red Hat. All rights reserved.
ValidIdRanges.html 0000664 0000000 0000000 00000011210 13565604617 0034104 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/class-useCopyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/package-frame.html 0000664 0000000 0000000 00000007441 13565604617 0032306 0 ustar 00root root 0000000 0000000| Enum | Description |
|---|---|
| Message.Format |
The possible format types.
|
| Transform.TransformType |
The transform type
|
| Annotation Type | Description |
|---|---|
| BaseUrl |
Messages on reports can have a link to a resolution document.
|
| Cause |
Mark a parameter as being the "exception cause" parameter rather than a positional format parameter.
|
| ConstructType |
Indicates the value of this annotation should be constructed and returned.
|
| Field |
Indicate that a method parameter value should be applied to a field on the resultant exception object.
|
| Fields |
Defines the default field properties to use on the resultant exception object.
|
| FormatWith |
Indicate that the given parameter should be wrapped with a formatting object of the given class.
|
| LoggingClass |
Mark a parameter as specifying the name of the logging class to use.
|
| LogMessage |
A typed logger method.
|
| Message |
Assigns a message string to a resource method.
|
| MessageBundle |
Signify that an interface is a message bundle interface.
|
| MessageLogger |
Signify that an interface is a typed logger interface.
|
| Once |
Indicates a message should only be logged once.
|
| Param |
Identifies a parameter is to be used for constructing an exception and excluded from the formatting of the message.
|
| Pos | |
| Producer |
Identifies a parameter has the ability to produce a
Throwable or a super type of a Throwable. |
| Properties |
Defines the default properties to use on the resultant exception object.
|
| Property |
Indicate that a method parameter value should be applied to a property (with a setter method) on the resultant
exception object.
|
| ResolutionDoc |
Allows a link to be created for messages on a report which contain a possible resolution to the issue reported .
|
| Signature |
Specifies the exact signature to use when creating a
Throwable return type. |
| Suppressed |
Indicates the parameter should be added as a suppressed exception to
the returned exception.
|
| Transform |
Indicate the given parameter should be transformed in each of the
transform types
provided. |
| ValidIdRange |
Sets a range of valid id's allowed on the
message id. |
| ValidIdRanges |
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/package-tree.html 0000664 0000000 0000000 00000036024 13565604617 0032152 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/org/jboss/logging/annotations/package-use.html 0000664 0000000 0000000 00000012456 13565604617 0032012 0 ustar 00root root 0000000 0000000| Class and Description |
|---|
| Message.Format
The possible format types.
|
| Transform.TransformType
The transform type
|
Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/overview-tree.html 0000664 0000000 0000000 00000035166 13565604617 0024541 0 ustar 00root root 0000000 0000000Copyright © 2019 JBoss by Red Hat. All rights reserved.
jboss-logging-tools-2.2.1.Final/docs/apidocs/package-list 0000664 0000000 0000000 00000000036 13565604617 0023323 0 ustar 00root root 0000000 0000000 org.jboss.logging.annotations jboss-logging-tools-2.2.1.Final/docs/apidocs/script.js 0000664 0000000 0000000 00000001473 13565604617 0022704 0 ustar 00root root 0000000 0000000 function show(type) { count = 0; for (var key in methods) { var row = document.getElementById(key); if ((methods[key] & type) != 0) { row.style.display = ''; row.className = (count++ % 2) ? rowColor : altColor; } else row.style.display = 'none'; } updateTabs(type); } function updateTabs(type) { for (var value in tabs) { var sNode = document.getElementById(tabs[value][0]); var spanNode = sNode.firstChild; if (value == type) { sNode.className = activeTableTab; spanNode.innerHTML = tabs[value][1]; } else { sNode.className = tableTab; spanNode.innerHTML = "" + tabs[value][1] + ""; } } } jboss-logging-tools-2.2.1.Final/docs/apidocs/stylesheet.css 0000664 0000000 0000000 00000031052 13565604617 0023741 0 ustar 00root root 0000000 0000000 /* Javadoc style sheet */ /* Overall document style */ @import url('resources/fonts/dejavu.css'); body { background-color:#ffffff; color:#353833; font-family:'DejaVu Sans', Arial, Helvetica, sans-serif; font-size:14px; margin:0; } a:link, a:visited { text-decoration:none; color:#4A6782; } a:hover, a:focus { text-decoration:none; color:#bb7a2a; } a:active { text-decoration:none; color:#4A6782; } a[name] { color:#353833; } a[name]:hover { text-decoration:none; color:#353833; } pre { font-family:'DejaVu Sans Mono', monospace; font-size:14px; } h1 { font-size:20px; } h2 { font-size:18px; } h3 { font-size:16px; font-style:italic; } h4 { font-size:13px; } h5 { font-size:12px; } h6 { font-size:11px; } ul { list-style-type:disc; } code, tt { font-family:'DejaVu Sans Mono', monospace; font-size:14px; padding-top:4px; margin-top:8px; line-height:1.4em; } dt code { font-family:'DejaVu Sans Mono', monospace; font-size:14px; padding-top:4px; } table tr td dt code { font-family:'DejaVu Sans Mono', monospace; font-size:14px; vertical-align:top; padding-top:4px; } sup { font-size:8px; } /* Document title and Copyright styles */ .clear { clear:both; height:0px; overflow:hidden; } .aboutLanguage { float:right; padding:0px 21px; font-size:11px; z-index:200; margin-top:-9px; } .legalCopy { margin-left:.5em; } .bar a, .bar a:link, .bar a:visited, .bar a:active { color:#FFFFFF; text-decoration:none; } .bar a:hover, .bar a:focus { color:#bb7a2a; } .tab { background-color:#0066FF; color:#ffffff; padding:8px; width:5em; font-weight:bold; } /* Navigation bar styles */ .bar { background-color:#4D7A97; color:#FFFFFF; padding:.8em .5em .4em .8em; height:auto;/*height:1.8em;*/ font-size:11px; margin:0; } .topNav { background-color:#4D7A97; color:#FFFFFF; float:left; padding:0; width:100%; clear:right; height:2.8em; padding-top:10px; overflow:hidden; font-size:12px; } .bottomNav { margin-top:10px; background-color:#4D7A97; color:#FFFFFF; float:left; padding:0; width:100%; clear:right; height:2.8em; padding-top:10px; overflow:hidden; font-size:12px; } .subNav { background-color:#dee3e9; float:left; width:100%; overflow:hidden; font-size:12px; } .subNav div { clear:left; float:left; padding:0 0 5px 6px; text-transform:uppercase; } ul.navList, ul.subNavList { float:left; margin:0 25px 0 0; padding:0; } ul.navList li{ list-style:none; float:left; padding: 5px 6px; text-transform:uppercase; } ul.subNavList li{ list-style:none; float:left; } .topNav a:link, .topNav a:active, .topNav a:visited, .bottomNav a:link, .bottomNav a:active, .bottomNav a:visited { color:#FFFFFF; text-decoration:none; text-transform:uppercase; } .topNav a:hover, .bottomNav a:hover { text-decoration:none; color:#bb7a2a; text-transform:uppercase; } .navBarCell1Rev { background-color:#F8981D; color:#253441; margin: auto 5px; } .skipNav { position:absolute; top:auto; left:-9999px; overflow:hidden; } /* Page header and footer styles */ .header, .footer { clear:both; margin:0 20px; padding:5px 0 0 0; } .indexHeader { margin:10px; position:relative; } .indexHeader span{ margin-right:15px; } .indexHeader h1 { font-size:13px; } .title { color:#2c4557; margin:10px 0; } .subTitle { margin:5px 0 0 0; } .header ul { margin:0 0 15px 0; padding:0; } .footer ul { margin:20px 0 5px 0; } .header ul li, .footer ul li { list-style:none; font-size:13px; } /* Heading styles */ div.details ul.blockList ul.blockList ul.blockList li.blockList h4, div.details ul.blockList ul.blockList ul.blockListLast li.blockList h4 { background-color:#dee3e9; border:1px solid #d0d9e0; margin:0 0 6px -8px; padding:7px 5px; } ul.blockList ul.blockList ul.blockList li.blockList h3 { background-color:#dee3e9; border:1px solid #d0d9e0; margin:0 0 6px -8px; padding:7px 5px; } ul.blockList ul.blockList li.blockList h3 { padding:0; margin:15px 0; } ul.blockList li.blockList h2 { padding:0px 0 20px 0; } /* Page layout container styles */ .contentContainer, .sourceContainer, .classUseContainer, .serializedFormContainer, .constantValuesContainer { clear:both; padding:10px 20px; position:relative; } .indexContainer { margin:10px; position:relative; font-size:12px; } .indexContainer h2 { font-size:13px; padding:0 0 3px 0; } .indexContainer ul { margin:0; padding:0; } .indexContainer ul li { list-style:none; padding-top:2px; } .contentContainer .description dl dt, .contentContainer .details dl dt, .serializedFormContainer dl dt { font-size:12px; font-weight:bold; margin:10px 0 0 0; color:#4E4E4E; } .contentContainer .description dl dd, .contentContainer .details dl dd, .serializedFormContainer dl dd { margin:5px 0 10px 0px; font-size:14px; font-family:'DejaVu Sans Mono',monospace; } .serializedFormContainer dl.nameValue dt { margin-left:1px; font-size:1.1em; display:inline; font-weight:bold; } .serializedFormContainer dl.nameValue dd { margin:0 0 0 1px; font-size:1.1em; display:inline; } /* List styles */ ul.horizontal li { display:inline; font-size:0.9em; } ul.inheritance { margin:0; padding:0; } ul.inheritance li { display:inline; list-style:none; } ul.inheritance li ul.inheritance { margin-left:15px; padding-left:15px; padding-top:1px; } ul.blockList, ul.blockListLast { margin:10px 0 10px 0; padding:0; } ul.blockList li.blockList, ul.blockListLast li.blockList { list-style:none; margin-bottom:15px; line-height:1.4; } ul.blockList ul.blockList li.blockList, ul.blockList ul.blockListLast li.blockList { padding:0px 20px 5px 10px; border:1px solid #ededed; background-color:#f8f8f8; } ul.blockList ul.blockList ul.blockList li.blockList, ul.blockList ul.blockList ul.blockListLast li.blockList { padding:0 0 5px 8px; background-color:#ffffff; border:none; } ul.blockList ul.blockList ul.blockList ul.blockList li.blockList { margin-left:0; padding-left:0; padding-bottom:15px; border:none; } ul.blockList ul.blockList ul.blockList ul.blockList li.blockListLast { list-style:none; border-bottom:none; padding-bottom:0; } table tr td dl, table tr td dl dt, table tr td dl dd { margin-top:0; margin-bottom:1px; } /* Table styles */ .overviewSummary, .memberSummary, .typeSummary, .useSummary, .constantsSummary, .deprecatedSummary { width:100%; border-left:1px solid #EEE; border-right:1px solid #EEE; border-bottom:1px solid #EEE; } .overviewSummary, .memberSummary { padding:0px; } .overviewSummary caption, .memberSummary caption, .typeSummary caption, .useSummary caption, .constantsSummary caption, .deprecatedSummary caption { position:relative; text-align:left; background-repeat:no-repeat; color:#253441; font-weight:bold; clear:none; overflow:hidden; padding:0px; padding-top:10px; padding-left:1px; margin:0px; white-space:pre; } .overviewSummary caption a:link, .memberSummary caption a:link, .typeSummary caption a:link, .useSummary caption a:link, .constantsSummary caption a:link, .deprecatedSummary caption a:link, .overviewSummary caption a:hover, .memberSummary caption a:hover, .typeSummary caption a:hover, .useSummary caption a:hover, .constantsSummary caption a:hover, .deprecatedSummary caption a:hover, .overviewSummary caption a:active, .memberSummary caption a:active, .typeSummary caption a:active, .useSummary caption a:active, .constantsSummary caption a:active, .deprecatedSummary caption a:active, .overviewSummary caption a:visited, .memberSummary caption a:visited, .typeSummary caption a:visited, .useSummary caption a:visited, .constantsSummary caption a:visited, .deprecatedSummary caption a:visited { color:#FFFFFF; } .overviewSummary caption span, .memberSummary caption span, .typeSummary caption span, .useSummary caption span, .constantsSummary caption span, .deprecatedSummary caption span { white-space:nowrap; padding-top:5px; padding-left:12px; padding-right:12px; padding-bottom:7px; display:inline-block; float:left; background-color:#F8981D; border: none; height:16px; } .memberSummary caption span.activeTableTab span { white-space:nowrap; padding-top:5px; padding-left:12px; padding-right:12px; margin-right:3px; display:inline-block; float:left; background-color:#F8981D; height:16px; } .memberSummary caption span.tableTab span { white-space:nowrap; padding-top:5px; padding-left:12px; padding-right:12px; margin-right:3px; display:inline-block; float:left; background-color:#4D7A97; height:16px; } .memberSummary caption span.tableTab, .memberSummary caption span.activeTableTab { padding-top:0px; padding-left:0px; padding-right:0px; background-image:none; float:none; display:inline; } .overviewSummary .tabEnd, .memberSummary .tabEnd, .typeSummary .tabEnd, .useSummary .tabEnd, .constantsSummary .tabEnd, .deprecatedSummary .tabEnd { display:none; width:5px; position:relative; float:left; background-color:#F8981D; } .memberSummary .activeTableTab .tabEnd { display:none; width:5px; margin-right:3px; position:relative; float:left; background-color:#F8981D; } .memberSummary .tableTab .tabEnd { display:none; width:5px; margin-right:3px; position:relative; background-color:#4D7A97; float:left; } .overviewSummary td, .memberSummary td, .typeSummary td, .useSummary td, .constantsSummary td, .deprecatedSummary td { text-align:left; padding:0px 0px 12px 10px; } th.colOne, th.colFirst, th.colLast, .useSummary th, .constantsSummary th, td.colOne, td.colFirst, td.colLast, .useSummary td, .constantsSummary td{ vertical-align:top; padding-right:0px; padding-top:8px; padding-bottom:3px; } th.colFirst, th.colLast, th.colOne, .constantsSummary th { background:#dee3e9; text-align:left; padding:8px 3px 3px 7px; } td.colFirst, th.colFirst { white-space:nowrap; font-size:13px; } td.colLast, th.colLast { font-size:13px; } td.colOne, th.colOne { font-size:13px; } .overviewSummary td.colFirst, .overviewSummary th.colFirst, .useSummary td.colFirst, .useSummary th.colFirst, .overviewSummary td.colOne, .overviewSummary th.colOne, .memberSummary td.colFirst, .memberSummary th.colFirst, .memberSummary td.colOne, .memberSummary th.colOne, .typeSummary td.colFirst{ width:25%; vertical-align:top; } td.colOne a:link, td.colOne a:active, td.colOne a:visited, td.colOne a:hover, td.colFirst a:link, td.colFirst a:active, td.colFirst a:visited, td.colFirst a:hover, td.colLast a:link, td.colLast a:active, td.colLast a:visited, td.colLast a:hover, .constantValuesContainer td a:link, .constantValuesContainer td a:active, .constantValuesContainer td a:visited, .constantValuesContainer td a:hover { font-weight:bold; } .tableSubHeadingColor { background-color:#EEEEFF; } .altColor { background-color:#FFFFFF; } .rowColor { background-color:#EEEEEF; } /* Content styles */ .description pre { margin-top:0; } .deprecatedContent { margin:0; padding:10px 0; } .docSummary { padding:0; } ul.blockList ul.blockList ul.blockList li.blockList h3 { font-style:normal; } div.block { font-size:14px; font-family:'DejaVu Serif', Georgia, "Times New Roman", Times, serif; } td.colLast div { padding-top:0px; } td.colLast a { padding-bottom:3px; } /* Formatting effect styles */ .sourceLineNo { color:green; padding:0 30px 0 0; } h1.hidden { visibility:hidden; overflow:hidden; font-size:10px; } .block { display:block; margin:3px 10px 2px 0px; color:#474747; } .deprecatedLabel, .descfrmTypeLabel, .memberNameLabel, .memberNameLink, .overrideSpecifyLabel, .packageHierarchyLabel, .paramLabel, .returnLabel, .seeLabel, .simpleTagLabel, .throwsLabel, .typeNameLabel, .typeNameLink { font-weight:bold; } .deprecationComment, .emphasizedPhrase, .interfaceName { font-style:italic; } div.block div.block span.deprecationComment, div.block div.block span.emphasizedPhrase, div.block div.block span.interfaceName { font-style:normal; } div.contentContainer ul.blockList li.blockList h2{ padding-bottom:0px; } jboss-logging-tools-2.2.1.Final/docs/default-notes.html 0000664 0000000 0000000 00000104703 13565604617 0023060 0 ustar 00root root 0000000 0000000| A message is inheritable if the two methods have the same name and same number of format parameters. |
A format parameter is a parameter that has no annotations or is annotated with one of the following annotations; @FormatWith, @Pos or @Transform.
|
Below are some example use case snippets from the examples.
/**
* Writes the value of the object to the file.
*
* @param value the value to write, cannot be {@code null}
*
* @throws UncheckedIOException if an error occurs writing the data
*/
public void write(final Object value) {
AppLogger.LOGGER.appVersion("ContentWriter", 1, 0, 0, "Beta1"); (1)
Objects.requireNonNull(value, ErrorMessages.MESSAGES.nullParam("value")); (2)
write(Objects.requireNonNull(value, ErrorMessages.MESSAGES.nullParam("value")).toString());
}
/**
* Writes the value to the file.
*
* @param value the value to write, cannot be {@code null} or an {@linkplain String#isEmpty() empty string}.
*
* @throws UncheckedIOException if an error occurs writing the data
*/
public void write(final String value) {
AppLogger.LOGGER.appVersion("ContentWriter", 1, 0, 0, "Beta1");
if (Objects.requireNonNull(value, ErrorMessages.MESSAGES.nullParam("value")).isEmpty()) {
throw ErrorMessages.MESSAGES.invalidValue(value); (3)
}
try {
synchronized (outputLock) {
writer.write(value);
writer.newLine();
if (autoFlush) {
flush();
}
}
} catch (IOException e) {
throw ErrorMessages.MESSAGES.operationFailed(UncheckedIOException::new, e, "write"); (4)
}
}
@Override
public void close() {
try {
synchronized (outputLock) {
writer.close();
}
AppLogger.LOGGER.tracef("ContentWriter %s was successfully closed.", this);
} catch (Exception e) {
throw ErrorMessages.MESSAGES.closeFailure(e, this);
}
}
/**
* Safely close this writer logging any errors that occur during closing.
*/
public void safeClose() {
try {
synchronized (outputLock) {
writer.close();
}
AppLogger.LOGGER.tracef("ContentWriter %s was successfully closed.", this);
} catch (Exception e) {
AppLogger.LOGGER.closeFailure(e, this); (5)
}
}| 1 | Logs the application version. Note this uses the @Once annotation to indicate this should only be logged once regardless of which write method is used. |
| 2 | The ErrorMessages.nullParam() returns a java.lang.function.Supplier. This allows the message to be lazily formatted only if the value is null. |
| 3 | Throws a message if the value is an empty string. |
| 4 | Uses a java.lang.function.BiFunction to create a new UncheckedIOException with the caught exception set as the cause. |
| 5 | Logs the caught exception instead of throwing a new exception. |
| Message Id | Message | Log Level | Return Type |
|---|---|---|---|
— |
%s version %d.%d.%d.%s |
INFO |
|
Failure while closing %s |
ERROR |
|
|
Encoding %s could not be found. Defaulting to %s. |
WARN |
|
|
CW000102 |
Cache size changed to %d |
INFO |
|
| Message Id | Message | Log Level | Return Type |
|---|---|---|---|
— |
Version %d.%d.%d.%s |
— |
|
CW000001 |
Value %s is invalid |
— |
|
CW000002 |
Failure closing %s |
— |
|
Parameter %s cannot be null |
— |
|
|
CW000004 |
Operation %s failed. |
— |
|
Expressions are in the form of ${key:defaultValue}. If the key is prefixed with sys. a system property is
used. If the key is prefixed with env. an environment variable is used. In all other cases the properties are resolved
from the org.jboss.logging.tools.expressionProperties path. If the key is not found in the properties the default
value will be used.
|
| Expressions are processed at compile time. The values will be hard-coded in the generated source files. |
To get started you need to include three dependencies in your project.
Required at compile time and runtime. |
|
Required at compile time only. |
|
Required at compile time only. |
If you’re using maven here is an example pom.xml snippet:
<dependencies>
<!-- Required by the annotation processor and will be used at runtime -->
<dependency>
<groupId>org.jboss.logging</groupId>
<artifactId>jboss-logging</artifactId>
</dependency>
<dependency>
<groupId>org.jboss.logging</groupId>
<artifactId>jboss-logging-annotations</artifactId>
<version>2.2.1.Final</version>
<!-- This is a compile-time dependency of this project, but is not needed at compile or runtime by other
projects that depend on this project.-->
<scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.jboss.logging</groupId>
<artifactId>jboss-logging-processor</artifactId>
<version>2.2.1.Final</version>
<!-- This is a compile-time dependency of this project, but is not needed at compile or runtime by other
projects that depend on this project.-->
<scope>provided</scope>
<optional>true</optional>
</dependency>
</dependencies>Once your project is configured you can create either a message bundle interface or a message logger interface. For detailed information see the JavaDocs for the annotations.
The JBoss logging tools are used to create internationalized log statements and exceptions.
To get started you need to include three dependencies in your project.
Required at compile time and runtime. |
|
Required at compile time only. |
|
Required at compile time only. |
If you’re using maven here is an example pom.xml snippet:
<dependencies>
<!-- Required by the annotation processor and will be used at runtime -->
<dependency>
<groupId>org.jboss.logging</groupId>
<artifactId>jboss-logging</artifactId>
</dependency>
<dependency>
<groupId>org.jboss.logging</groupId>
<artifactId>jboss-logging-annotations</artifactId>
<version>2.2.1.Final</version>
<!-- This is a compile-time dependency of this project, but is not needed at compile or runtime by other
projects that depend on this project.-->
<scope>provided</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.jboss.logging</groupId>
<artifactId>jboss-logging-processor</artifactId>
<version>2.2.1.Final</version>
<!-- This is a compile-time dependency of this project, but is not needed at compile or runtime by other
projects that depend on this project.-->
<scope>provided</scope>
<optional>true</optional>
</dependency>
</dependencies>Once your project is configured you can create either a message bundle interface or a message logger interface. For detailed information see the JavaDocs for the annotations.
Message bundle interfaces provide a way to internationalize exceptions or strings. A message bundle interface is
annotated with @MessageBundle. Each method in must be annotated with @Message
which will be used to determine the String used for either the return type or the message for the exception being
returned.
The value for a @Message may contain an expression.
Expressions are in the form of ${key:defaultValue}. If the key is prefixed with sys. a system property is
used. If the key is prefixed with env. an environment variable is used. In all other cases the properties are resolved
from the org.jboss.logging.tools.expressionProperties path. If the key is not found in the properties the default
value will be used.
|
| Expressions are processed at compile time. The values will be hard-coded in the generated source files. |
The following constraints are placed on methods in a message bundle:
The return type must be one of the follow
A java.lang.String
A java.lang.Throwable or a subtype of java.lang.Throwable
A java.lang.function.Supplier who’s return type fits one of the other two constraints above.
The method must be annotated with @Message or a message must be inheritable.
A method can have only one @Cause parameter.
A method can only have one @Producer parameter.
| A message is inheritable if the two methods have the same name and same number of format parameters. |
A format parameter is a parameter that has no annotations or is annotated with one of the following annotations; @FormatWith, @Pos or @Transform.
|
@MessageBundle(projectCode = "CW") (1)
public interface ErrorMessages {
ErrorMessages MESSAGES = Messages.getBundle(ErrorMessages.class);
@Message("Version %d.%d.%d.%s") (2)
String version(int major, int minor, int macro, String rel);
@Message(id = 1, value = "Value '%s' is invalid")
IllegalArgumentException invalidValue(Object value);
@Message(id = 2, value = "Failure closing %s") (3)
CloseException closeFailure(@Cause Throwable cause, @Param @Pos(1) Closeable c);
CloseException closeFailure(@Cause Throwable cause, @Param @Pos(1) Closeable c, @Suppressed Throwable... errors);
@Message(id = 3, value = "Parameter %s cannot be null")
Supplier<String> nullParam(String name);
@Message(id = 4, value = "Operation %s failed.")
<T extends RuntimeException> T operationFailed(@Producer Function<String, T> fn, String name); (4)
<T extends RuntimeException> T operationFailed(@Producer BiFunction<String, IOException, T> fn, @Cause IOException cause, String name);
}| 1 | The projectCode will be prepended to messages which have an id specified. For example with id = 1 the message will be prepended with CW000001. You can control the number padding with the length property on the annotation. |
| 2 | No id is specified for this message which means no id will be prepended on this message. |
| 3 | The @Param annotation tells the generator that the parameter should be used to construct the CloseException. The @Pos(1) annotation indicates the parameter should also be used when formatting the message. |
| 4 | The @Producer annotation indicates that the Function should be used to create the exception being returned. |
| Message bundle interfaces can also contain valid message logger methods. |
Logger interfaces provide a way to internationalize log messages. A logger interface is an interface annotated with
@MessageLogger. Each method in must be annotated with @Message which will
be used to determine the message to be logged.
The value for a @Message may contain an expression.
Expressions are in the form of ${key:defaultValue}. If the key is prefixed with sys. a system property is
used. If the key is prefixed with env. an environment variable is used. In all other cases the properties are resolved
from the org.jboss.logging.tools.expressionProperties path. If the key is not found in the properties the default
value will be used.
|
| Expressions are processed at compile time. The values will be hard-coded in the generated source files. |
The following constraints are placed on methods in a message logger:
The method must have a void return type
The method must be annotated with @LogMessage
The method must be annotated with @Message or a message must be inheritable.
A method can have only one @Cause parameter.
| A message is inheritable if the two methods have the same name and same number of format parameters. |
A format parameter is a parameter that has no annotations or is annotated with one of the following annotations; @FormatWith, @Pos or @Transform.
|
A message logger interface may also extend the org.jboss.logging.BasicLogger. This allows the logging interface to be usable for standard logging. For example AppLogger.LOGGER.debugf("Initializing %s", this);
@MessageLogger(projectCode = "CW") (1)
public interface AppLogger extends BasicLogger {
AppLogger LOGGER = Logger.getMessageLogger(AppLogger.class, AppLogger.class.getPackage().getName());
@LogMessage
@Once (2)
@Message("%s version %d.%d.%d.%s") (3)
void appVersion(CharSequence name, int major, int minor, int macro, String rel);
@LogMessage(level = Logger.Level.ERROR) (4)
@Message(id = 100, value = "Failure while closing %s")
void closeFailure(@Cause Throwable cause, Object obj);
@LogMessage(level = Logger.Level.WARN)
@Message(id = 101, value = "Encoding %s could not be found. Defaulting to %s.")
void encodingNotFound(String encoding, Charset dft);
@LogMessage
@Message(id = 102, value = "Cache size changed to '%d'")
void cacheSizeChanged(@Transform(Transform.TransformType.SIZE) Collection<String> c);
@LogMessage
void cacheSizeChanged(@Transform(Transform.TransformType.SIZE) String... array);
@LogMessage
void cacheSizeChanged(@Transform(Transform.TransformType.SIZE) Map<String, Object> map);
}| 1 | The projectCode will be prepended to messages which have an id specified. For example with id = 100 the message will be prepended with CW000100. You can control the number padding with the length property on the annotation. |
| 2 | Ensures the log message is only written once. |
| 3 | No id is specified for this message which means no id will be prepended on this message. |
| 4 | Overrides the default level to ERROR to indicate an error message should be logged. |
There are currently two types of reports that can be generated. The options are adoc or asciidoc for asciidoc and xml for XML.
The reports contain the following data:
The formatted message id.
A possible link to a resolution document for the error.
The unformatted message.
The log level, if applicable.
The return type, if applicable.
Two annotations can be used to assist withing linking resolution documents for messages.
This annotation can be used on a type to define the base URL for linking resolution documents. This annotation is not required for links to be created on reports.
This annotation is used to define information about the resolution document for creating links. If placed on an interface all methods that have a defined id will have a link generated. This can also be placed individually on the method to only generate links for specific id’s.
Below are some example use case snippets from the examples.
/**
* Writes the value of the object to the file.
*
* @param value the value to write, cannot be {@code null}
*
* @throws UncheckedIOException if an error occurs writing the data
*/
public void write(final Object value) {
AppLogger.LOGGER.appVersion("ContentWriter", 1, 0, 0, "Beta1"); (1)
Objects.requireNonNull(value, ErrorMessages.MESSAGES.nullParam("value")); (2)
write(Objects.requireNonNull(value, ErrorMessages.MESSAGES.nullParam("value")).toString());
}
/**
* Writes the value to the file.
*
* @param value the value to write, cannot be {@code null} or an {@linkplain String#isEmpty() empty string}.
*
* @throws UncheckedIOException if an error occurs writing the data
*/
public void write(final String value) {
AppLogger.LOGGER.appVersion("ContentWriter", 1, 0, 0, "Beta1");
if (Objects.requireNonNull(value, ErrorMessages.MESSAGES.nullParam("value")).isEmpty()) {
throw ErrorMessages.MESSAGES.invalidValue(value); (3)
}
try {
synchronized (outputLock) {
writer.write(value);
writer.newLine();
if (autoFlush) {
flush();
}
}
} catch (IOException e) {
throw ErrorMessages.MESSAGES.operationFailed(UncheckedIOException::new, e, "write"); (4)
}
}
@Override
public void close() {
try {
synchronized (outputLock) {
writer.close();
}
AppLogger.LOGGER.tracef("ContentWriter %s was successfully closed.", this);
} catch (Exception e) {
throw ErrorMessages.MESSAGES.closeFailure(e, this);
}
}
/**
* Safely close this writer logging any errors that occur during closing.
*/
public void safeClose() {
try {
synchronized (outputLock) {
writer.close();
}
AppLogger.LOGGER.tracef("ContentWriter %s was successfully closed.", this);
} catch (Exception e) {
AppLogger.LOGGER.closeFailure(e, this); (5)
}
}| 1 | Logs the application version. Note this uses the @Once annotation to indicate this should only be logged once regardless of which write method is used. |
| 2 | The ErrorMessages.nullParam() returns a java.lang.function.Supplier. This allows the message to be lazily formatted only if the value is null. |
| 3 | Throws a message if the value is an empty string. |
| 4 | Uses a java.lang.function.BiFunction to create a new UncheckedIOException with the caught exception set as the cause. |
| 5 | Logs the caught exception instead of throwing a new exception. |
The translation properties files must exist in the same directory structure as the interface. The name of the properties file InterfaceName.i18n_language_country_variant.properties. For example if you have a class named org.jboss.logging.tools.examples.ErrorMessages and you want to translate this into French you create a properties file called ErrorMessages.i18n_fr.properties in a directory org/jboss/logging/tools/examples.
You can pass options to an annotation processor with the -A compiler option. For example to disable generating the @Generated annotation from being placed on the generated source files you would pass -Aorg.jboss.logging.tools.addGeneratedAnnotation=false to the compiler command.
| Option | Description |
|---|---|
|
This option turns on debug logging for the processor |
|
This option allows you to define a path where, at compile-time, expressions in messages can be resolved. |
|
If set to |
In Java 9 the @javax.annotation.Generated was moved to @javax.annotation.processor.Generated. The processor attempts to determine which annotation to use by attempting to find the @javax.annotation.Generated first. If it fails the @javax.annotation.processor.Generated is attempted. If neither can be found no annotation will be placed on the generated implementations.
|
Expressions are in the form of ${key:defaultValue}. If the key is prefixed with sys. a system property is
used. If the key is prefixed with env. an environment variable is used. In all other cases the properties are resolved
from the org.jboss.logging.tools.expressionProperties path. If the key is not found in the properties the default
value will be used.
|
| Expressions are processed at compile time. The values will be hard-coded in the generated source files. |
| Option | Description |
|---|---|
|
The base path for the translated properties files. This defaults to the location where new class files are placed. |
|
If set to |
|
If defined this indicates the path a skeleton file should be generated for the interface. The generated skeleton file will be placed in a directory that matches the package with a name that matches the interface with a |
|
Sets the maximum level to include in the generated skeleton files. For example if set to |
|
By default when generating a skeleton translation file an index will be appended to the format pattern. For example |
| Option | Description |
|---|---|
|
Indicates the type of report that should be generated. The current report types are |
|
The path where the generated reports should be placed. This defaults to the location where new class files are placed. |
|
An optional title for the report. For asciidoc this defaults to |
Message bundle interfaces provide a way to internationalize exceptions or strings. A message bundle interface is
annotated with @MessageBundle. Each method in must be annotated with @Message
which will be used to determine the String used for either the return type or the message for the exception being
returned.
The value for a @Message may contain an expression.
Expressions are in the form of ${key:defaultValue}. If the key is prefixed with sys. a system property is
used. If the key is prefixed with env. an environment variable is used. In all other cases the properties are resolved
from the org.jboss.logging.tools.expressionProperties path. If the key is not found in the properties the default
value will be used.
|
| Expressions are processed at compile time. The values will be hard-coded in the generated source files. |
The following constraints are placed on methods in a message bundle:
The return type must be one of the follow
A java.lang.String
A java.lang.Throwable or a subtype of java.lang.Throwable
A java.lang.function.Supplier who’s return type fits one of the other two constraints above.
The method must be annotated with @Message or a message must be inheritable.
A method can have only one @Cause parameter.
A method can only have one @Producer parameter.
| A message is inheritable if the two methods have the same name and same number of format parameters. |
A format parameter is a parameter that has no annotations or is annotated with one of the following annotations; @FormatWith, @Pos or @Transform.
|
@MessageBundle(projectCode = "CW") (1)
public interface ErrorMessages {
ErrorMessages MESSAGES = Messages.getBundle(ErrorMessages.class);
@Message("Version %d.%d.%d.%s") (2)
String version(int major, int minor, int macro, String rel);
@Message(id = 1, value = "Value '%s' is invalid")
IllegalArgumentException invalidValue(Object value);
@Message(id = 2, value = "Failure closing %s") (3)
CloseException closeFailure(@Cause Throwable cause, @Param @Pos(1) Closeable c);
CloseException closeFailure(@Cause Throwable cause, @Param @Pos(1) Closeable c, @Suppressed Throwable... errors);
@Message(id = 3, value = "Parameter %s cannot be null")
Supplier<String> nullParam(String name);
@Message(id = 4, value = "Operation %s failed.")
<T extends RuntimeException> T operationFailed(@Producer Function<String, T> fn, String name); (4)
<T extends RuntimeException> T operationFailed(@Producer BiFunction<String, IOException, T> fn, @Cause IOException cause, String name);
}| 1 | The projectCode will be prepended to messages which have an id specified. For example with id = 1 the message will be prepended with CW000001. You can control the number padding with the length property on the annotation. |
| 2 | No id is specified for this message which means no id will be prepended on this message. |
| 3 | The @Param annotation tells the generator that the parameter should be used to construct the CloseException. The @Pos(1) annotation indicates the parameter should also be used when formatting the message. |
| 4 | The @Producer annotation indicates that the Function should be used to create the exception being returned. |
| Message bundle interfaces can also contain valid message logger methods. |
Logger interfaces provide a way to internationalize log messages. A logger interface is an interface annotated with
@MessageLogger. Each method in must be annotated with @Message which will
be used to determine the message to be logged.
The value for a @Message may contain an expression.
Expressions are in the form of ${key:defaultValue}. If the key is prefixed with sys. a system property is
used. If the key is prefixed with env. an environment variable is used. In all other cases the properties are resolved
from the org.jboss.logging.tools.expressionProperties path. If the key is not found in the properties the default
value will be used.
|
| Expressions are processed at compile time. The values will be hard-coded in the generated source files. |
The following constraints are placed on methods in a message logger:
The method must have a void return type
The method must be annotated with @LogMessage
The method must be annotated with @Message or a message must be inheritable.
A method can have only one @Cause parameter.
| A message is inheritable if the two methods have the same name and same number of format parameters. |
A format parameter is a parameter that has no annotations or is annotated with one of the following annotations; @FormatWith, @Pos or @Transform.
|
A message logger interface may also extend the org.jboss.logging.BasicLogger. This allows the logging interface to be usable for standard logging. For example AppLogger.LOGGER.debugf("Initializing %s", this);
@MessageLogger(projectCode = "CW") (1)
public interface AppLogger extends BasicLogger {
AppLogger LOGGER = Logger.getMessageLogger(AppLogger.class, AppLogger.class.getPackage().getName());
@LogMessage
@Once (2)
@Message("%s version %d.%d.%d.%s") (3)
void appVersion(CharSequence name, int major, int minor, int macro, String rel);
@LogMessage(level = Logger.Level.ERROR) (4)
@Message(id = 100, value = "Failure while closing %s")
void closeFailure(@Cause Throwable cause, Object obj);
@LogMessage(level = Logger.Level.WARN)
@Message(id = 101, value = "Encoding %s could not be found. Defaulting to %s.")
void encodingNotFound(String encoding, Charset dft);
@LogMessage
@Message(id = 102, value = "Cache size changed to '%d'")
void cacheSizeChanged(@Transform(Transform.TransformType.SIZE) Collection<String> c);
@LogMessage
void cacheSizeChanged(@Transform(Transform.TransformType.SIZE) String... array);
@LogMessage
void cacheSizeChanged(@Transform(Transform.TransformType.SIZE) Map<String, Object> map);
}| 1 | The projectCode will be prepended to messages which have an id specified. For example with id = 100 the message will be prepended with CW000100. You can control the number padding with the length property on the annotation. |
| 2 | Ensures the log message is only written once. |
| 3 | No id is specified for this message which means no id will be prepended on this message. |
| 4 | Overrides the default level to ERROR to indicate an error message should be logged. |
You can pass options to an annotation processor with the -A compiler option. For example to disable generating the @Generated annotation from being placed on the generated source files you would pass -Aorg.jboss.logging.tools.addGeneratedAnnotation=false to the compiler command.
| Option | Description |
|---|---|
|
This option turns on debug logging for the processor |
|
This option allows you to define a path where, at compile-time, expressions in messages can be resolved. |
|
If set to |
In Java 9 the @javax.annotation.Generated was moved to @javax.annotation.processor.Generated. The processor attempts to determine which annotation to use by attempting to find the @javax.annotation.Generated first. If it fails the @javax.annotation.processor.Generated is attempted. If neither can be found no annotation will be placed on the generated implementations.
|
Expressions are in the form of ${key:defaultValue}. If the key is prefixed with sys. a system property is
used. If the key is prefixed with env. an environment variable is used. In all other cases the properties are resolved
from the org.jboss.logging.tools.expressionProperties path. If the key is not found in the properties the default
value will be used.
|
| Expressions are processed at compile time. The values will be hard-coded in the generated source files. |
| Option | Description |
|---|---|
|
The base path for the translated properties files. This defaults to the location where new class files are placed. |
|
If set to |
|
If defined this indicates the path a skeleton file should be generated for the interface. The generated skeleton file will be placed in a directory that matches the package with a name that matches the interface with a |
|
Sets the maximum level to include in the generated skeleton files. For example if set to |
|
By default when generating a skeleton translation file an index will be appended to the format pattern. For example |
| Option | Description |
|---|---|
|
Indicates the type of report that should be generated. The current report types are |
|
The path where the generated reports should be placed. This defaults to the location where new class files are placed. |
|
An optional title for the report. For asciidoc this defaults to |
There are currently two types of reports that can be generated. The options are adoc or asciidoc for asciidoc and xml for XML.
The reports contain the following data:
The formatted message id.
A possible link to a resolution document for the error.
The unformatted message.
The log level, if applicable.
The return type, if applicable.
Two annotations can be used to assist withing linking resolution documents for messages.
This annotation can be used on a type to define the base URL for linking resolution documents. This annotation is not required for links to be created on reports.
This annotation is used to define information about the resolution document for creating links. If placed on an interface all methods that have a defined id will have a link generated. This can also be placed individually on the method to only generate links for specific id’s.
The translation properties files must exist in the same directory structure as the interface. The name of the properties file InterfaceName.i18n_language_country_variant.properties. For example if you have a class named org.jboss.logging.tools.examples.ErrorMessages and you want to translate this into French you create a properties file called ErrorMessages.i18n_fr.properties in a directory org/jboss/logging/tools/examples.