pax_global_header 0000666 0000000 0000000 00000000064 12551760010 0014507 g ustar 00root root 0000000 0000000 52 comment=2220c252663bbb8e6b1994c2881847881ceabbc4
jboss-logging-tools-2.0.1.Final/ 0000775 0000000 0000000 00000000000 12551760010 0016441 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/.gitignore 0000664 0000000 0000000 00000000376 12551760010 0020437 0 ustar 00root root 0000000 0000000 #Ignore Maven target folder
target/
#Ignore Eclipse files
.settings/
.classpath
.project
#Ignore Intellij files
*.iml
*.iws
*.ipr
.idea/
#Ignore Mac files
.DS_Store
/core/target/
/base/target/
nb-configuration.xml
/processor/target/
/generator/target/ jboss-logging-tools-2.0.1.Final/annotations/ 0000775 0000000 0000000 00000000000 12551760010 0020776 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/annotations/pom.xml 0000664 0000000 0000000 00000003467 12551760010 0022325 0 ustar 00root root 0000000 0000000
4.0.0org.jboss.loggingjboss-logging-tools-parent2.0.1.Final../pom.xmljboss-logging-annotationsjarJBoss Logging I18n AnnotationsApache License, version 2.0http://www.apache.org/licenses/LICENSE-2.0.txtrepoorg.jboss.loggingjboss-loggingprovided jboss-logging-tools-2.0.1.Final/annotations/src/ 0000775 0000000 0000000 00000000000 12551760010 0021565 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/annotations/src/main/ 0000775 0000000 0000000 00000000000 12551760010 0022511 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/annotations/src/main/java/ 0000775 0000000 0000000 00000000000 12551760010 0023432 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/annotations/src/main/java/org/ 0000775 0000000 0000000 00000000000 12551760010 0024221 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/annotations/src/main/java/org/jboss/ 0000775 0000000 0000000 00000000000 12551760010 0025341 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/annotations/src/main/java/org/jboss/logging/ 0000775 0000000 0000000 00000000000 12551760010 0026767 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/annotations/src/main/java/org/jboss/logging/annotations/ 0000775 0000000 0000000 00000000000 12551760010 0031324 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/annotations/src/main/java/org/jboss/logging/annotations/Cause.java 0000664 0000000 0000000 00000002336 12551760010 0033233 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 12551760010 0034737 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.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.0.1.Final/annotations/src/main/java/org/jboss/logging/annotations/Field.java 0000664 0000000 0000000 00000002622 12551760010 0033214 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;
/**
* Indicate that a method parameter value should be applied to a field on the resultant exception object.
*
* @author David M. Lloyd
*/
@Retention(CLASS)
@Target(PARAMETER)
@Documented
public @interface Field {
/**
* The field name. If not specified, the parameter name is assumed to be the field name.
*
* @return the field name
*/
String name() default "";
}
FormatWith.java 0000664 0000000 0000000 00000003417 12551760010 0034201 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.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 12551760010 0034137 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.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 12551760010 0034467 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.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.0.1.Final/annotations/src/main/java/org/jboss/logging/annotations/Message.java0000664 0000000 0000000 00000004532 12551760010 0033557 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.
*
* @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 00000003566 12551760010 0034640 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.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;
/**
* 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;
}
MessageLogger.java 0000664 0000000 0000000 00000004144 12551760010 0034637 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.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;
/**
* 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;
}
jboss-logging-tools-2.0.1.Final/annotations/src/main/java/org/jboss/logging/annotations/Once.java 0000664 0000000 0000000 00000002674 12551760010 0033064 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.0.1.Final/annotations/src/main/java/org/jboss/logging/annotations/Param.java 0000664 0000000 0000000 00000003454 12551760010 0033235 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.0.1.Final/annotations/src/main/java/org/jboss/logging/annotations/Pos.java 0000664 0000000 0000000 00000002730 12551760010 0032732 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 {};
}
Property.java 0000664 0000000 0000000 00000002671 12551760010 0033742 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.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 a method parameter value should be applied to a property (with a setter method) on the resultant exception object.
*
* @author David M. Lloyd
*/
@Retention(CLASS)
@Target(PARAMETER)
@Documented
public @interface Property {
/**
* The property name. If not specified, the parameter name is assumed to be the property name.
*
* @return the property name
*/
String name() default "";
}
Transform.java 0000664 0000000 0000000 00000005574 12551760010 0034076 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.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:
*
*
* @return an array of the transform types
*/
TransformType[] value();
}
ValidIdRange.java 0000664 0000000 0000000 00000004565 12551760010 0034413 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.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;
/**
* Sets a range of valid id's allowed on the {@link org.jboss.logging.annotations.Message#id() message id}. Both {@link
* Message#INHERIT} and {@link 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.
*
*
*
*
*
* @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 12551760010 0034570 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.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.0.1.Final/pom.xml 0000664 0000000 0000000 00000007575 12551760010 0017774 0 ustar 00root root 0000000 0000000
4.0.0org.jbossjboss-parent14org.jboss.loggingjboss-logging-tools-parent2.0.1.FinalpomJBoss Logging Tools ParentJames R. Perkinsjperkins@redhat.comKevin Polletkevin.pollet@serli.comUTF-82.0.0.Final3.1.2.GA1.3.2.Final6.3.1lgplhttp://repository.jboss.org/licenses/lgpl-2.1.txtrepoorg.jboss.loggingjboss-logging-annotations${project.version}org.jboss.loggingjboss-logging${version.org.jboss.logging}org.jboss.jdeparserjdeparser${version.org.jboss.jdeparser}org.jboss.logmanagerjboss-logmanager${version.org.jboss.logmanager}org.testngtestng${version.org.testng}annotationsprocessorprocessor-tests
jboss-logging-tools-2.0.1.Final/processor-tests/ 0000775 0000000 0000000 00000000000 12551760010 0021620 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor-tests/pom.xml 0000664 0000000 0000000 00000012660 12551760010 0023142 0 ustar 00root root 0000000 0000000
4.0.0org.jboss.loggingjboss-logging-tools-parent2.0.1.Final../pom.xmljboss-logging-processor-testsjarJBoss Logging Processor tests
Tests the current plugin currently with a legacy version of JBoss Logging
org.jboss.loggingjboss-logging-annotationstestorg.jboss.loggingjboss-logging-processor${project.parent.version}testorg.jboss.loggingjboss-loggingtestorg.jboss.logmanagerjboss-logmanagertestorg.testngtestngtest../processor/src/test/java../processor/src/test/resourcesorg.apache.maven.pluginsmaven-install-plugintrueorg.apache.maven.pluginsmaven-deploy-plugintrueorg.apache.maven.pluginsmaven-compiler-plugin**/LegacyLogger.java**/LegacyLoggerTest.java**/LegacyMessages.java**/LegacyMessagesTest.java**/GeneratedSourceAnalysisTest.javaorg.apache.maven.pluginsmaven-surefire-pluginorg.jboss.logmanager.LogManagerlogging30true3.0.1.GAorg.apache.maven.pluginsmaven-compiler-plugin-AloggingVersion=3.0 jboss-logging-tools-2.0.1.Final/processor/ 0000775 0000000 0000000 00000000000 12551760010 0020460 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/pom.xml 0000664 0000000 0000000 00000010023 12551760010 0021771 0 ustar 00root root 0000000 0000000
4.0.0org.jboss.loggingjboss-logging-tools-parent2.0.1.Final../pom.xmljboss-logging-processorjarJBoss Logging I18n Annotation Processororg.jboss.loggingjboss-logging-annotationsorg.jboss.loggingjboss-loggingprovidedorg.jboss.jdeparserjdeparserorg.jboss.logmanagerjboss-logmanagertestorg.testngtestngtestorg.apache.maven.pluginsmaven-compiler-plugindefault-compilecompilecompile-proc:noneorg.apache.maven.pluginsmaven-surefire-pluginorg.jboss.logmanager.LogManager${project.build.testSourceDirectory}${project.build.directory}/generated-test-sources/test-annotations jboss-logging-tools-2.0.1.Final/processor/src/ 0000775 0000000 0000000 00000000000 12551760010 0021247 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/ 0000775 0000000 0000000 00000000000 12551760010 0022173 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/ 0000775 0000000 0000000 00000000000 12551760010 0023114 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/ 0000775 0000000 0000000 00000000000 12551760010 0023703 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/jboss/ 0000775 0000000 0000000 00000000000 12551760010 0025023 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/jboss/logging/ 0000775 0000000 0000000 00000000000 12551760010 0026451 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/jboss/logging/processor/ 0000775 0000000 0000000 00000000000 12551760010 0030470 5 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/jboss/logging/processor/apt/ 0000775 0000000 0000000 00000000000 12551760010 0031254 5 ustar 00root root 0000000 0000000 AbstractGenerator.java 0000664 0000000 0000000 00000007715 12551760010 0035464 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/jboss/logging/processor/apt /*
* JBoss, Home of Professional Open Source.
* Copyright 2012, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.logging.processor.apt;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import javax.annotation.processing.Filer;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.SupportedOptions;
import javax.lang.model.element.TypeElement;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
import org.jboss.logging.processor.model.MessageInterface;
/**
* An abstract processor used process annotations.
*
* @author James R. Perkins
* @author Kevin Pollet - SERLI - (kevin.pollet@serli.com)
*/
public abstract class AbstractGenerator {
private final ToolLogger logger;
private final ProcessingEnvironment processingEnv;
/**
* Constructs a new processor.
*
* @param processingEnv the processing environment.
*/
AbstractGenerator(final ProcessingEnvironment processingEnv) {
this.logger = ToolLogger.getLogger(processingEnv);
this.processingEnv = processingEnv;
}
/**
* Processes a type element.
*
* @param annotation the annotation who trigger the processing
* @param element the element that contains the methods.
* @param messageInterface the message interface to implement.
*/
public abstract void processTypeElement(final TypeElement annotation, final TypeElement element, final MessageInterface messageInterface);
/**
* Returns the logger to log messages with.
*
* @return the logger to log messages with.
*/
final ToolLogger logger() {
return logger;
}
/**
* Returns the filer.
*
* @return the filer
*/
final Filer filer() {
return processingEnv.getFiler();
}
/**
* Returns the element utils.
*
* @return the utils
*/
final Elements elementUtils() {
return processingEnv.getElementUtils();
}
/**
* Returns the type utils.
*
* @return the utils
*/
public final Types typeUtils() {
return processingEnv.getTypeUtils();
}
/**
* Returns the processing environment.
*
* @return the processing environment being used.
*/
public final ProcessingEnvironment processingEnv() {
return processingEnv;
}
/**
* Returns the name of the processor.
*
* @return the name of the processor.
*/
public final String getName() {
return this.getClass().getSimpleName();
}
/**
* Returns the supported options set.
*
* @return the supported options set or empty set if none
*/
public final Set getSupportedOptions() {
SupportedOptions options = this.getClass().getAnnotation(SupportedOptions.class);
if (options != null) {
return new HashSet(Arrays.asList(options.value()));
}
return Collections.emptySet();
}
}
AbstractMessageObjectType.java 0000664 0000000 0000000 00000003776 12551760010 0037116 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/jboss/logging/processor/apt package org.jboss.logging.processor.apt;
import static org.jboss.logging.processor.util.ElementHelper.typeToString;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeParameterElement;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.type.WildcardType;
import javax.lang.model.util.ElementFilter;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
import org.jboss.logging.processor.model.MessageObjectType;
/**
* @author James R. Perkins
*/
abstract class AbstractMessageObjectType implements MessageObjectType {
protected final Elements elements;
protected final Types types;
protected final TypeMirror typeMirror;
protected AbstractMessageObjectType(final Elements elements, final Types types, final TypeMirror typeMirror) {
this.elements = elements;
this.types = types;
this.typeMirror = typeMirror;
}
protected AbstractMessageObjectType(final Elements elements, final Types types, final Element element) {
this.elements = elements;
this.types = types;
this.typeMirror = element.asType();
}
@Override
public String type() {
return name();
}
@Override
public final boolean isAssignableFrom(final Class type) {
final TypeMirror typeMirror = elements.getTypeElement(typeToString(type)).asType();
return types.isAssignable(types.erasure(typeMirror), types.erasure(this.typeMirror));
}
@Override
public final boolean isSubtypeOf(final Class type) {
final TypeMirror typeMirror = elements.getTypeElement(typeToString(type)).asType();
return types.isSubtype(types.erasure(this.typeMirror), types.erasure(typeMirror));
}
@Override
public final boolean isSameAs(final Class type) {
return type().equals(typeToString(type));
}
}
ImplementationClassGenerator.java 0000664 0000000 0000000 00000005351 12551760010 0037666 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/jboss/logging/processor/apt /*
* JBoss, Home of Professional Open Source.
* Copyright 2012, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.logging.processor.apt;
import java.io.IOException;
import java.util.Map;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.TypeElement;
import org.jboss.logging.processor.generator.model.ClassModel;
import org.jboss.logging.processor.generator.model.ClassModelFactory;
import org.jboss.logging.processor.model.MessageInterface;
import org.jboss.logging.processor.util.VersionComparator;
/**
* A generator for creating implementations of message bundle and logging
* interfaces.
*
* @author James R. Perkins
*/
final class ImplementationClassGenerator extends AbstractGenerator {
private static final String LOGGING_VERSION = "loggingVersion";
private final boolean useLogging31;
/**
* @param processingEnv the processing environment.
*/
public ImplementationClassGenerator(ProcessingEnvironment processingEnv) {
super(processingEnv);
final Map options = processingEnv.getOptions();
if (options.containsKey(LOGGING_VERSION)) {
final String loggingVersion = options.get(LOGGING_VERSION);
useLogging31 = (VersionComparator.compareVersion(loggingVersion, "3.1") >= 0);
} else {
useLogging31 = true;
}
}
@Override
public void processTypeElement(final TypeElement annotation, final TypeElement element, final MessageInterface messageInterface) {
try {
final ClassModel classModel = ClassModelFactory.implementation(filer(), messageInterface, useLogging31);
classModel.generateAndWrite();
} catch (IllegalStateException | IOException e) {
logger().error(element, e);
}
}
}
LoggingToolsProcessor.java 0000664 0000000 0000000 00000020377 12551760010 0036360 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/jboss/logging/processor/apt /*
* JBoss, Home of Professional Open Source.
* Copyright 2012, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.logging.processor.apt;
import static javax.lang.model.util.ElementFilter.typesIn;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedOptions;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
import org.jboss.logging.annotations.Cause;
import org.jboss.logging.annotations.Field;
import org.jboss.logging.annotations.FormatWith;
import org.jboss.logging.annotations.LogMessage;
import org.jboss.logging.annotations.LoggingClass;
import org.jboss.logging.annotations.Message;
import org.jboss.logging.annotations.MessageBundle;
import org.jboss.logging.annotations.MessageLogger;
import org.jboss.logging.annotations.Param;
import org.jboss.logging.annotations.Pos;
import org.jboss.logging.annotations.Property;
import org.jboss.logging.annotations.Transform;
import org.jboss.logging.annotations.ValidIdRange;
import org.jboss.logging.annotations.ValidIdRanges;
import org.jboss.logging.processor.model.MessageInterface;
import org.jboss.logging.processor.util.ElementHelper;
import org.jboss.logging.processor.validation.ValidationMessage;
import org.jboss.logging.processor.validation.Validator;
/**
* The main annotation processor for JBoss Logging Tooling.
*
* @author James R. Perkins
* @author Kevin Pollet - SERLI - (kevin.pollet@serli.com)
*/
@SupportedOptions({
LoggingToolsProcessor.DEBUG_OPTION
})
public class LoggingToolsProcessor extends AbstractProcessor {
public static final String DEBUG_OPTION = "debug";
private final List interfaceAnnotations = Arrays.asList(MessageBundle.class.getName(), MessageLogger.class.getName());
private final List generators;
private final Set supportedAnnotations;
private ToolLogger logger;
/**
* Default constructor.
*/
public LoggingToolsProcessor() {
this.generators = new ArrayList<>();
final Set annotations = new HashSet<>();
// Interface annotations
annotations.addAll(interfaceAnnotations);
// Other annotations
annotations.add(Cause.class.getName());
annotations.add(Field.class.getName());
annotations.add(FormatWith.class.getName());
annotations.add(LoggingClass.class.getName());
annotations.add(LogMessage.class.getName());
annotations.add(Message.class.getName());
annotations.add(Param.class.getName());
annotations.add(Pos.class.getName());
annotations.add(Property.class.getName());
annotations.add(Transform.class.getName());
annotations.add(ValidIdRange.class.getName());
annotations.add(ValidIdRanges.class.getName());
this.supportedAnnotations = Collections.unmodifiableSet(annotations);
}
@Override
public Set getSupportedOptions() {
Set supportedOptions = new HashSet();
//Add global options
SupportedOptions globalOptions = this.getClass().getAnnotation(SupportedOptions.class);
if (globalOptions != null) {
supportedOptions.addAll(Arrays.asList(globalOptions.value()));
}
//Add tool processors options
for (AbstractGenerator generator : generators) {
supportedOptions.addAll(generator.getSupportedOptions());
}
return supportedOptions;
}
@Override
public Set getSupportedAnnotationTypes() {
return supportedAnnotations;
}
@Override
public SourceVersion getSupportedSourceVersion() {
return SourceVersion.latest();
}
@Override
public synchronized void init(final ProcessingEnvironment processingEnv) {
super.init(processingEnv);
logger = ToolLogger.getLogger(processingEnv);
//Tools generator - Note the order these are executed in.
generators.add(new ImplementationClassGenerator(processingEnv));
generators.add(new TranslationClassGenerator(processingEnv));
generators.add(new TranslationFileGenerator(processingEnv));
}
@Override
public boolean process(final Set annotations, final RoundEnvironment roundEnv) {
boolean process = true;
final Validator validator = new Validator();
//Call jboss logging tools
for (TypeElement annotation : annotations) {
// We only want to process the interface annotations
if (interfaceAnnotations.contains(annotation.getQualifiedName().toString())) {
try {
final Set interfaces = typesIn(roundEnv.getElementsAnnotatedWith(annotation));
for (TypeElement interfaceElement : interfaces) {
try {
final MessageInterface messageInterface = MessageInterfaceFactory.of(processingEnv, interfaceElement);
final Collection validationMessages = validator.validate(messageInterface);
for (ValidationMessage message : validationMessages) {
final Element element = ElementHelper.fromMessageObject(message.getMessageObject());
switch (message.type()) {
case ERROR: {
logger.error(element, message.getMessage());
process = false;
break;
}
case WARN: {
logger.warn(element, message.getMessage());
break;
}
default: {
logger.note(element, message.getMessage());
}
}
}
if (process) {
if (interfaceElement.getKind().isInterface()
&& !interfaceElement.getModifiers().contains(Modifier.PRIVATE)) {
for (AbstractGenerator processor : generators) {
logger.debug("Executing processor %s", processor.getName());
processor.processTypeElement(annotation, interfaceElement, messageInterface);
}
}
}
} catch (ProcessingException e) {
logger.error(e.getElement(), e.getMessage());
}
}
} catch (Throwable t) {
logger.error(annotation, t);
}
}
}
return process;
}
}
MessageInterfaceFactory.java 0000664 0000000 0000000 00000033252 12551760010 0036602 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/jboss/logging/processor/apt /*
* JBoss, Home of Professional Open Source.
* Copyright 2012, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.logging.processor.apt;
import static org.jboss.logging.processor.util.Objects.HashCodeBuilder;
import static org.jboss.logging.processor.util.Objects.ToStringBuilder;
import static org.jboss.logging.processor.util.Objects.areEqual;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.util.ElementFilter;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
import org.jboss.logging.BasicLogger;
import org.jboss.logging.annotations.MessageBundle;
import org.jboss.logging.annotations.MessageLogger;
import org.jboss.logging.annotations.ValidIdRange;
import org.jboss.logging.annotations.ValidIdRanges;
import org.jboss.logging.processor.model.MessageInterface;
import org.jboss.logging.processor.model.MessageMethod;
import org.jboss.logging.processor.util.ElementHelper;
/**
* A factory to create a {@link org.jboss.logging.processor.model.MessageInterface} for annotation processors.
*
* @author James R. Perkins
*/
public final class MessageInterfaceFactory {
private static final Object LOCK = new Object();
private static volatile LoggerInterface LOGGER_INTERFACE;
/**
* Private constructor for factory.
*/
private MessageInterfaceFactory() {
}
/**
* Creates a message interface from the {@link javax.lang.model.element.TypeElement} specified by the {@code
* interfaceElement} parameter.
*
* @param processingEnvironment the annotation processing environment.
* @param interfaceElement the interface element to parse.
*
* @return a message interface for the interface element.
*/
public static MessageInterface of(final ProcessingEnvironment processingEnvironment, final TypeElement interfaceElement) {
final Types types = processingEnvironment.getTypeUtils();
final Elements elements = processingEnvironment.getElementUtils();
if (types.isSameType(interfaceElement.asType(), elements.getTypeElement(BasicLogger.class.getName()).asType())) {
MessageInterface result = LOGGER_INTERFACE;
if (result == null) {
synchronized (LOCK) {
result = LOGGER_INTERFACE;
if (result == null) {
LOGGER_INTERFACE = LoggerInterface.of(elements, types);
result = LOGGER_INTERFACE;
}
}
}
return result;
}
final AptMessageInterface result = new AptMessageInterface(interfaceElement, types, elements);
result.init();
for (TypeMirror typeMirror : interfaceElement.getInterfaces()) {
final MessageInterface extended = MessageInterfaceFactory.of(processingEnvironment, (TypeElement) types.asElement(typeMirror));
result.extendedInterfaces.add(extended);
result.extendedInterfaces.addAll(extended.extendedInterfaces());
}
return result;
}
/**
* Message interface implementation.
*/
private static class AptMessageInterface extends AbstractMessageObjectType implements MessageInterface {
private final TypeElement interfaceElement;
private final Set extendedInterfaces;
private final List messageMethods;
private final List validIdRanges;
private String projectCode;
private String packageName;
private String simpleName;
private String qualifiedName;
private String fqcn;
private int idLen;
private AptMessageInterface(final TypeElement interfaceElement, final Types types, final Elements elements) {
super(elements, types, interfaceElement);
this.interfaceElement = interfaceElement;
this.messageMethods = new LinkedList();
this.extendedInterfaces = new LinkedHashSet();
if (ElementHelper.isAnnotatedWith(interfaceElement, ValidIdRanges.class)) {
validIdRanges = Arrays.asList(interfaceElement.getAnnotation(ValidIdRanges.class).value());
} else if (ElementHelper.isAnnotatedWith(interfaceElement, ValidIdRange.class)) {
validIdRanges = Arrays.asList(interfaceElement.getAnnotation(ValidIdRange.class));
} else {
validIdRanges = Collections.emptyList();
}
}
@Override
public boolean extendsLoggerInterface() {
return LOGGER_INTERFACE != null && extendedInterfaces.contains(LOGGER_INTERFACE);
}
@Override
public String name() {
return qualifiedName;
}
@Override
public Set extendedInterfaces() {
return Collections.unmodifiableSet(extendedInterfaces);
}
@Override
public int hashCode() {
return HashCodeBuilder.builder().add(name()).toHashCode();
}
@Override
public Collection methods() {
return messageMethods;
}
@Override
public int compareTo(final MessageInterface o) {
return this.name().compareTo(o.name());
}
@Override
public String projectCode() {
return projectCode;
}
private void init() {
// Keeping below for now
final Collection methods = ElementFilter.methodsIn(interfaceElement.getEnclosedElements());
final MessageMethodBuilder builder = MessageMethodBuilder.create(elements, types);
for (ExecutableElement param : methods) {
builder.add(param);
}
final Collection m = builder.build();
if (m != null)
this.messageMethods.addAll(m);
final MessageBundle messageBundle = interfaceElement.getAnnotation(MessageBundle.class);
final MessageLogger messageLogger = interfaceElement.getAnnotation(MessageLogger.class);
if (messageBundle != null) {
projectCode = messageBundle.projectCode();
idLen = messageBundle.length();
} else if (messageLogger != null) {
projectCode = messageLogger.projectCode();
idLen = messageLogger.length();
} // TODO (jrp) this should cause an error
qualifiedName = elements.getBinaryName(interfaceElement).toString();
final int lastDot = qualifiedName.lastIndexOf(".");
if (lastDot > 0) {
packageName = qualifiedName.substring(0, lastDot);
simpleName = qualifiedName.substring(lastDot + 1);
} else {
packageName = null;
simpleName = qualifiedName;
}
// Get the FQCN
final TypeElement loggingClass = ElementHelper.getClassAnnotationValue(interfaceElement, MessageLogger.class, "loggingClass");
if (loggingClass != null) {
final String value = loggingClass.getQualifiedName().toString();
if (!value.equals(Void.class.getName())) {
fqcn = value;
}
}
}
@Override
public String type() {
return name();
}
@Override
public String packageName() {
return packageName;
}
@Override
public String getComment() {
return elements.getDocComment(interfaceElement);
}
@Override
public String simpleName() {
return simpleName;
}
@Override
public String loggingFQCN() {
return fqcn;
}
@Override
public AnnotatedType getAnnotatedType() {
if (ElementHelper.isAnnotatedWith(interfaceElement, MessageLogger.class)) {
return AnnotatedType.MESSAGE_LOGGER;
} else if (ElementHelper.isAnnotatedWith(interfaceElement, MessageBundle.class)) {
return AnnotatedType.MESSAGE_BUNDLE;
}
return AnnotatedType.NONE;
}
@Override
public List validIdRanges() {
return validIdRanges;
}
@Override
public int getIdLength() {
return idLen;
}
@Override
public boolean equals(final Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof AptMessageInterface)) {
return false;
}
final AptMessageInterface other = (AptMessageInterface) obj;
return areEqual(name(), other.name());
}
@Override
public String toString() {
return ToStringBuilder.of(this).add(qualifiedName).toString();
}
@Override
public TypeElement reference() {
return interfaceElement;
}
}
private static class LoggerInterface extends AbstractMessageObjectType implements MessageInterface {
private final TypeElement loggerInterface;
private final Set messageMethods;
private LoggerInterface(final Elements elements, final Types types) {
// TODO (jrp) BasicLogger type can likely be initialized once
super(elements, types, elements.getTypeElement(BasicLogger.class.getName()));
messageMethods = new LinkedHashSet();
this.loggerInterface = elements.getTypeElement(BasicLogger.class.getName());
}
private void init() {
final MessageMethodBuilder builder = MessageMethodBuilder.create(elements, types);
List methods = ElementFilter.methodsIn(loggerInterface.getEnclosedElements());
for (ExecutableElement method : methods) {
builder.add(method);
}
final Collection m = builder.build();
this.messageMethods.addAll(m);
}
static LoggerInterface of(final Elements elements, final Types types) {
final LoggerInterface result = new LoggerInterface(elements, types);
result.init();
return result;
}
@Override
public boolean extendsLoggerInterface() {
return false;
}
@Override
public Set extendedInterfaces() {
return Collections.emptySet();
}
@Override
public Collection methods() {
return messageMethods;
}
@Override
public String projectCode() {
return null;
}
@Override
public String name() {
return BasicLogger.class.getName();
}
@Override
public String packageName() {
return BasicLogger.class.getPackage().getName();
}
@Override
public String simpleName() {
return BasicLogger.class.getSimpleName();
}
@Override
public String loggingFQCN() {
return null;
}
@Override
public AnnotatedType getAnnotatedType() {
return AnnotatedType.NONE;
}
@Override
public List validIdRanges() {
return Collections.emptyList();
}
@Override
public int getIdLength() {
return -1;
}
@Override
public TypeElement reference() {
return loggerInterface;
}
@Override
public int hashCode() {
return HashCodeBuilder.builder().add(name()).toHashCode();
}
@Override
public boolean equals(final Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof AptMessageInterface)) {
return false;
}
final AptMessageInterface other = (AptMessageInterface) obj;
return areEqual(name(), other.name());
}
@Override
public int compareTo(final MessageInterface o) {
return this.name().compareTo(o.name());
}
@Override
public String toString() {
return ToStringBuilder.of(this).add(name()).toString();
}
@Override
public String getComment() {
return elements.getDocComment(loggerInterface);
}
}
}
MessageMethodBuilder.java 0000664 0000000 0000000 00000037632 12551760010 0036107 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/jboss/logging/processor/apt /*
* JBoss, Home of Professional Open Source.
* Copyright 2012, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.logging.processor.apt;
import static java.util.Collections.unmodifiableSet;
import static org.jboss.logging.processor.util.ElementHelper.findByName;
import static org.jboss.logging.processor.util.ElementHelper.inheritsMessage;
import static org.jboss.logging.processor.util.ElementHelper.isOverloaded;
import static org.jboss.logging.processor.util.ElementHelper.parameterCount;
import static org.jboss.logging.processor.util.Objects.HashCodeBuilder;
import static org.jboss.logging.processor.util.Objects.ToStringBuilder;
import static org.jboss.logging.processor.util.Objects.areEqual;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
import org.jboss.logging.Logger;
import org.jboss.logging.annotations.LogMessage;
import org.jboss.logging.annotations.Message;
import org.jboss.logging.annotations.Message.Format;
import org.jboss.logging.processor.model.MessageMethod;
import org.jboss.logging.processor.model.Parameter;
import org.jboss.logging.processor.model.Parameter.ParameterType;
import org.jboss.logging.processor.model.ReturnType;
import org.jboss.logging.processor.model.ThrowableType;
import org.jboss.logging.processor.util.Comparison;
import org.jboss.logging.processor.util.ElementHelper;
/**
* Date: 29.07.2011
*
* @author James R. Perkins
*/
final class MessageMethodBuilder {
private static final String MESSAGE_METHOD_SUFFIX = "$str";
private final List methods;
private final Elements elements;
private final Types types;
private MessageMethodBuilder(final Elements elements, final Types types) {
this.elements = elements;
this.types = types;
methods = new LinkedList<>();
}
MessageMethodBuilder add(final ExecutableElement method) {
methods.add(method);
return this;
}
Set build() {
final Set result = new LinkedHashSet<>();
for (ExecutableElement elementMethod : methods) {
final AptMessageMethod resultMethod = new AptMessageMethod(elements, elementMethod);
resultMethod.inheritsMessage = inheritsMessage(methods, elementMethod);
resultMethod.message = findMessage(methods, elementMethod);
resultMethod.isOverloaded = isOverloaded(methods, elementMethod);
for (TypeMirror thrownType : elementMethod.getThrownTypes()) {
resultMethod.thrownTypes.add(ThrowableTypeFactory.of(elements, types, thrownType));
}
// Create a list of parameters
for (Parameter parameter : ParameterFactory.of(elements, types, resultMethod.method)) {
resultMethod.add(parameter);
}
// Check to see if the method is overloaded
if (resultMethod.isOverloaded()) {
resultMethod.messageMethodName = resultMethod.name() + resultMethod.formatParameterCount() + MESSAGE_METHOD_SUFFIX;
resultMethod.translationKey = resultMethod.name() + "." + resultMethod.formatParameterCount();
} else {
resultMethod.messageMethodName = resultMethod.name() + MESSAGE_METHOD_SUFFIX;
resultMethod.translationKey = resultMethod.name();
}
// Set the return type
resultMethod.returnType = ReturnTypeFactory.of(elements, types, elementMethod.getReturnType(), resultMethod);
result.add(resultMethod);
}
return Collections.unmodifiableSet(result);
}
private MessageMethod.Message findMessage(final Collection methods, final ExecutableElement method) {
AptMessage result = null;
Message message = method.getAnnotation(Message.class);
if (message != null) {
result = new AptMessage(message);
result.hasId = hasMessageId(message);
result.inheritsId = message.id() == Message.INHERIT;
if (result.inheritsId()) {
result.id = findMessageId(methods, method);
if (result.id > 0) {
result.hasId = true;
}
} else {
result.id = message.id();
}
} else {
final Collection allMethods = findByName(methods, method.getSimpleName(), parameterCount(method.getParameters()));
for (ExecutableElement m : allMethods) {
message = m.getAnnotation(Message.class);
if (message != null) {
result = new AptMessage(message);
result.hasId = hasMessageId(message);
result.inheritsId = message.id() == Message.INHERIT;
if (result.inheritsId()) {
result.id = findMessageId(methods, m);
if (result.id > 0) {
result.hasId = true;
}
} else {
result.id = message.id();
}
break;
}
}
}
return result;
}
private int findMessageId(final Collection methods, final ExecutableElement method) {
int result = -2;
final Collection allMethods = findByName(methods, method.getSimpleName());
for (ExecutableElement m : allMethods) {
final Message message = m.getAnnotation(Message.class);
if (message != null) {
if (message.id() != Message.INHERIT) {
result = message.id();
}
}
}
return result;
}
private boolean hasMessageId(final Message message) {
return message != null && (message.id() != Message.NONE && message.id() != Message.INHERIT);
}
static MessageMethodBuilder create(final Elements elements, final Types types) {
return new MessageMethodBuilder(elements, types);
}
/**
* An implementation for the MessageMethod interface.
*/
private static class AptMessageMethod implements MessageMethod {
private final Elements elements;
private final Map> parameters;
private final Set thrownTypes;
private final ExecutableElement method;
private ReturnType returnType;
private Parameter cause;
private boolean inheritsMessage;
private boolean isOverloaded;
private Message message;
private String messageMethodName;
private String translationKey;
/**
* Private constructor for the
*
* @param elements the elements utility.
* @param method the method to describe.
*/
AptMessageMethod(final Elements elements, final ExecutableElement method) {
this.elements = elements;
this.method = method;
inheritsMessage = false;
isOverloaded = false;
parameters = new EnumMap<>(ParameterType.class);
thrownTypes = new LinkedHashSet<>();
}
void add(final Parameter parameter) {
if (parameters.containsKey(ParameterType.ANY)) {
parameters.get(ParameterType.ANY).add(parameter);
} else {
final Set any = new LinkedHashSet<>();
any.add(parameter);
parameters.put(ParameterType.ANY, any);
}
if (parameters.containsKey(parameter.parameterType())) {
parameters.get(parameter.parameterType()).add(parameter);
} else {
final Set set = new LinkedHashSet<>();
set.add(parameter);
parameters.put(parameter.parameterType(), set);
}
if (parameter.parameterType() == ParameterType.CAUSE) {
cause = parameter;
}
}
@Override
public String name() {
return method.getSimpleName().toString();
}
@Override
public Set parameters(final ParameterType parameterType) {
if (parameters.containsKey(parameterType)) {
return parameters.get(parameterType);
}
return Collections.emptySet();
}
@Override
public Set parameters(final ParameterType parameterType, final ParameterType... parameterTypes) {
final Set result = new LinkedHashSet();
if (parameters.containsKey(parameterType)) {
result.addAll(parameters.get(parameterType));
}
for (ParameterType pt : parameterTypes) {
if (parameters.containsKey(pt)) {
result.addAll(parameters.get(pt));
}
}
return result;
}
@Override
public ReturnType returnType() {
return returnType;
}
@Override
public Set thrownTypes() {
return unmodifiableSet(thrownTypes);
}
@Override
public Message message() {
return message;
}
@Override
public boolean inheritsMessage() {
return inheritsMessage;
}
@Override
public String messageMethodName() {
return messageMethodName;
}
@Override
public String translationKey() {
return translationKey;
}
@Override
public boolean hasCause() {
return cause != null;
}
@Override
public boolean isOverloaded() {
return isOverloaded;
}
@Override
public Parameter cause() {
return cause;
}
@Override
public String loggerMethod() {
switch (message.format()) {
case MESSAGE_FORMAT:
return "logv";
case NO_FORMAT:
return "log";
case PRINTF:
return "logf";
default:
// Should never be hit
return "log";
}
}
@Override
public String logLevel() {
// TODO (jrp) possibly return the actual level
final LogMessage logMessage = method.getAnnotation(LogMessage.class);
final Logger.Level logLevel = (logMessage.level() == null ? Logger.Level.INFO : logMessage.level());
return String.format("%s.%s.%s", Logger.class.getName(), Logger.Level.class.getSimpleName(), logLevel.name());
}
@Override
public int formatParameterCount() {
int result = parameters(ParameterType.FORMAT, ParameterType.TRANSFORM).size();
for (Parameter params : parameters(ParameterType.POS)) {
result += params.pos().value().length;
}
return result;
}
@Override
public boolean isLoggerMethod() {
return ElementHelper.isAnnotatedWith(method, LogMessage.class);
}
@Override
public int hashCode() {
return HashCodeBuilder.builder()
.add(name())
.add(parameters(ParameterType.ANY))
.add(returnType()).toHashCode();
}
@Override
public boolean equals(final Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof AptMessageMethod)) {
return false;
}
final AptMessageMethod other = (AptMessageMethod) obj;
return areEqual(name(), other.name()) &&
areEqual(parameters, parameters) &&
areEqual(returnType, other.returnType);
}
@Override
public String toString() {
return ToStringBuilder.of(this)
.add("name", name())
.add("returnType", returnType())
.add("parameters", parameters(ParameterType.ANY))
.add("loggerMethod", loggerMethod()).toString();
}
@Override
public ExecutableElement reference() {
return method;
}
@Override
public int compareTo(final MessageMethod o) {
int result = name().compareTo(o.name());
result = (result != Comparison.EQUAL) ? result : returnType.name().compareTo(o.returnType().name());
// Size does matter
result = (result != Comparison.EQUAL) ? result : parameters(ParameterType.ANY).size() - o.parameters(ParameterType.ANY).size();
if (result == Comparison.EQUAL) {
// Check element by element
final Iterator params1 = parameters(ParameterType.ANY).iterator();
final Iterator params2 = o.parameters(ParameterType.ANY).iterator();
while (params1.hasNext()) {
if (params2.hasNext()) {
final Parameter param1 = params1.next();
final Parameter param2 = params2.next();
result = param1.compareTo(param2);
} else {
result = Comparison.GREATER;
}
// Short circuit
if (result != Comparison.EQUAL) break;
}
}
return result;
}
@Override
public String getComment() {
return elements.getDocComment(method);
}
}
private static class AptMessage implements MessageMethod.Message {
private final Message message;
private int id;
private boolean hasId;
private boolean inheritsId;
private AptMessage(final Message message) {
this.message = message;
}
@Override
public int id() {
return id;
}
@Override
public boolean hasId() {
return hasId;
}
@Override
public boolean inheritsId() {
return inheritsId;
}
@Override
public String value() {
return message.value();
}
@Override
public Format format() {
return message.format();
}
@Override
public String toString() {
return ToStringBuilder.of(this)
.add("hasId", hasId)
.add("id", id())
.add("inheritsId", inheritsId)
.add("value", value())
.add("formatType", format()).toString();
}
}
}
ParameterFactory.java 0000664 0000000 0000000 00000032070 12551760010 0035312 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/jboss/logging/processor/apt /*
* JBoss, Home of Professional Open Source.
* Copyright 2012, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.logging.processor.apt;
import static org.jboss.logging.processor.util.Objects.HashCodeBuilder;
import static org.jboss.logging.processor.util.Objects.ToStringBuilder;
import static org.jboss.logging.processor.util.Objects.areEqual;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.TypeKind;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
import org.jboss.logging.annotations.Cause;
import org.jboss.logging.annotations.Field;
import org.jboss.logging.annotations.FormatWith;
import org.jboss.logging.annotations.LoggingClass;
import org.jboss.logging.annotations.Param;
import org.jboss.logging.annotations.Pos;
import org.jboss.logging.annotations.Property;
import org.jboss.logging.annotations.Transform;
import org.jboss.logging.processor.model.MessageMethod;
import org.jboss.logging.processor.model.Parameter;
import org.jboss.logging.processor.util.Comparison;
import org.jboss.logging.processor.util.ElementHelper;
/**
* @author James R. Perkins - 20.Feb.2011
*/
final class ParameterFactory {
/**
* Private constructor for factory.
*/
private ParameterFactory() {
}
public static Set of(final Elements elements, final Types types, final ExecutableElement method) {
final Set result = new LinkedHashSet();
final List params = method.getParameters();
int index = 0;
for (VariableElement param : params) {
final TypeElement formatClassType = ElementHelper.getClassAnnotationValue(param, FormatWith.class);
final String formatClass = formatClassType == null ? null : formatClassType.getQualifiedName().toString();
final String qualifiedType;
if (param.asType().getKind().isPrimitive()) {
qualifiedType = param.asType().toString();
} else {
switch ((param.asType().getKind())) {
case ARRAY:
qualifiedType = param.asType().toString().replace("[]", "");
break;
default:
qualifiedType = types.asElement(param.asType()).toString();
break;
}
}
if (method.isVarArgs()) {
result.add(new AptParameter(elements, types, qualifiedType, param, formatClass, (++index == params.size())));
} else {
result.add(new AptParameter(elements, types, qualifiedType, param, formatClass, false));
}
}
return result;
}
public static Parameter forMessageMethod(final MessageMethod messageMethod) {
return new Parameter() {
@Override
public String formatterClass() {
return null;
}
@Override
public Class paramClass() {
return null;
}
@Override
public String targetName() {
return "";
}
@Override
public Transform transform() {
return null;
}
@Override
public Pos pos() {
return null;
}
@Override
public String type() {
return String.class.getName();
}
@Override
public String name() {
return messageMethod.messageMethodName();
}
@Override
public boolean isArray() {
return false;
}
@Override
public boolean isPrimitive() {
return false;
}
@Override
public boolean isVarArgs() {
return false;
}
@Override
public ParameterType parameterType() {
return ParameterType.MESSAGE;
}
@Override
public int hashCode() {
return HashCodeBuilder.builder()
.add(type())
.add(name()).toHashCode();
}
@Override
public boolean equals(final Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof AptParameter)) {
return false;
}
final AptParameter other = (AptParameter) obj;
return areEqual(type(), other.type()) && areEqual(name(), other.name());
}
@Override
public int compareTo(final Parameter other) {
return Comparison.begin()
.compare(this.type(), other.type())
.compare(this.name(), other.name()).result();
}
@Override
public String toString() {
return ToStringBuilder.of(this)
.add("name", name())
.add("type", type()).toString();
}
@Override
public MessageMethod reference() {
return messageMethod;
}
@Override
public boolean isAssignableFrom(final Class type) {
return String.class.isAssignableFrom(type);
}
@Override
public boolean isSubtypeOf(final Class type) {
return type.isAssignableFrom(String.class);
}
@Override
public boolean isSameAs(final Class type) {
return type().equals(type.getName());
}
};
}
private static class AptParameter extends AbstractMessageObjectType implements Parameter {
private final VariableElement param;
private final String qualifiedType;
private final String formatterClass;
private final Class paramClass;
private final boolean isVarArgs;
private final ParameterType parameterType;
private final Transform transform;
private final Pos pos;
/**
* Only allow construction from within the parent class.
*
* @param elements the element utilities from the annotation processor.
* @param types the type utilities from the annotation processor.
* @param qualifiedType the qualified type name of the parameter.
* @param param the parameter.
* @param formatterClass the formatter class, or {@code null} if none
* @param isVarArgs {@code true} if this is a vararg parameter, otherwise {@code false}.
*/
AptParameter(final Elements elements, final Types types, final String qualifiedType, final VariableElement param, final String formatterClass, final boolean isVarArgs) {
super(elements, types, param);
this.qualifiedType = qualifiedType;
this.param = param;
this.formatterClass = formatterClass;
if (ElementHelper.isAnnotatedWith(param, Param.class)) {
paramClass = Object.class;
parameterType = ParameterType.CONSTRUCTION;
transform = null;
pos = null;
} else if (ElementHelper.isAnnotatedWith(param, Cause.class)) {
paramClass = null;
parameterType = ParameterType.CAUSE;
transform = null;
pos = null;
} else if (ElementHelper.isAnnotatedWith(param, Field.class)) {
paramClass = null;
parameterType = ParameterType.FIELD;
transform = null;
pos = null;
} else if (ElementHelper.isAnnotatedWith(param, Property.class)) {
paramClass = null;
parameterType = ParameterType.PROPERTY;
transform = null;
pos = null;
} else if (ElementHelper.isAnnotatedWith(param, LoggingClass.class)) {
paramClass = null;
parameterType = ParameterType.FQCN;
transform = null;
pos = null;
} else if (ElementHelper.isAnnotatedWith(param, Transform.class)) {
paramClass = null;
parameterType = ParameterType.TRANSFORM;
transform = param.getAnnotation(Transform.class);
pos = null;
} else if (ElementHelper.isAnnotatedWith(param, Pos.class)) {
paramClass = null;
parameterType = ParameterType.POS;
transform = null;
pos = param.getAnnotation(Pos.class);
} else {
parameterType = ParameterType.FORMAT;
paramClass = null;
transform = null;
pos = null;
}
this.isVarArgs = isVarArgs;
}
@Override
public String type() {
return qualifiedType;
}
@Override
public String formatterClass() {
return formatterClass;
}
@Override
public String name() {
return param.getSimpleName().toString();
}
@Override
public boolean isArray() {
return param.asType().getKind() == TypeKind.ARRAY;
}
@Override
public boolean isPrimitive() {
return param.asType().getKind().isPrimitive();
}
@Override
public boolean isVarArgs() {
return isVarArgs;
}
@Override
public ParameterType parameterType() {
return parameterType;
}
@Override
public Class paramClass() {
return paramClass;
}
@Override
public String targetName() {
String result = "";
final Field field = param.getAnnotation(Field.class);
final Property property = param.getAnnotation(Property.class);
if (field != null) {
final String name = field.name();
if (name.isEmpty()) {
result = param.getSimpleName().toString();
} else {
result = name;
}
} else if (property != null) {
final String name = property.name();
if (name.isEmpty()) {
result = param.getSimpleName().toString();
} else {
result = name;
}
result = "set" + Character.toUpperCase(result.charAt(0)) + result.substring(1);
}
return result;
}
@Override
public Transform transform() {
return transform;
}
@Override
public Pos pos() {
return pos;
}
@Override
public int hashCode() {
return HashCodeBuilder.builder()
.add(qualifiedType)
.add(param).toHashCode();
}
@Override
public boolean equals(final Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof AptParameter)) {
return false;
}
final AptParameter other = (AptParameter) obj;
return areEqual(this.param, other.param) && areEqual(this.qualifiedType, other.qualifiedType);
}
@Override
public int compareTo(final Parameter other) {
return Comparison.begin()
.compare(this.type(), other.type())
.compare(this.name(), other.name()).result();
}
@Override
public String toString() {
return ToStringBuilder.of(this)
.add("name", name())
.add("type", type()).toString();
}
@Override
public VariableElement reference() {
return param;
}
}
}
ProcessingException.java 0000664 0000000 0000000 00000004206 12551760010 0036035 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/jboss/logging/processor/apt /*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.logging.processor.apt;
import javax.lang.model.element.Element;
/**
* An exception that can be used to log which element caused the error.
*
* @author James R. Perkins
*/
class ProcessingException extends RuntimeException {
private final Element element;
/**
* Creates a new exception.
*
* @param element the element the error occurs on
* @param message the message
*/
public ProcessingException(final Element element, final String message) {
super(message);
this.element = element;
}
/**
* Creates a new exception.
*
* @param element the element the error occurs on
* @param format the format for the message
* @param args the arguments for the format
*/
public ProcessingException(final Element element, final String format, final Object... args) {
super(String.format(format, args));
this.element = element;
}
/**
* The element the error occurred on.
*
* @return the element
*/
public Element getElement() {
return element;
}
}
ReturnTypeFactory.java 0000664 0000000 0000000 00000021011 12551760010 0035504 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/jboss/logging/processor/apt /*
* JBoss, Home of Professional Open Source.
* Copyright 2012, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.logging.processor.apt;
import static org.jboss.logging.processor.util.Objects.HashCodeBuilder;
import static org.jboss.logging.processor.util.Objects.areEqual;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.PrimitiveType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.util.ElementFilter;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
import org.jboss.logging.annotations.ConstructType;
import org.jboss.logging.processor.model.MessageMethod;
import org.jboss.logging.processor.model.Parameter;
import org.jboss.logging.processor.model.ReturnType;
import org.jboss.logging.processor.model.ThrowableType;
import org.jboss.logging.processor.util.ElementHelper;
import org.jboss.logging.processor.util.Objects;
/**
* Date: 29.07.2011
*
* @author James R. Perkins
*/
final class ReturnTypeFactory {
/**
* Private constructor for factory.
*/
private ReturnTypeFactory() {
}
public static ReturnType of(final Elements elements, final Types types, final TypeMirror returnType, final MessageMethod method) {
if (returnType.getKind() == TypeKind.VOID) {
return ReturnType.VOID;
}
final AptReturnType result = new AptReturnType(elements, types, returnType, method);
result.init();
return result;
}
/**
* Implementation of return type.
*/
private static class AptReturnType extends AbstractMessageObjectType implements ReturnType {
private final Map fields;
private final Map methods;
private final TypeMirror returnType;
private final MessageMethod method;
private ThrowableType throwableType;
AptReturnType(final Elements elements, final Types types, final TypeMirror returnType, final MessageMethod method) {
super(elements, types, returnType);
this.returnType = returnType;
this.method = method;
throwableType = null;
fields = new LinkedHashMap();
methods = new LinkedHashMap();
}
@Override
public boolean hasFieldFor(final Parameter parameter) {
return fields.containsKey(parameter.targetName()) && checkType(parameter, fields.get(parameter.targetName()));
}
@Override
public boolean hasMethodFor(final Parameter parameter) {
return methods.containsKey(parameter.targetName()) && checkType(parameter, methods.get(parameter.targetName()));
}
@Override
public boolean isThrowable() {
return isSubtypeOf(Throwable.class);
}
@Override
public boolean isPrimitive() {
return returnType.getKind().isPrimitive();
}
@Override
public String name() {
return returnType.toString();
}
@Override
public ThrowableType throwableReturnType() {
return throwableType;
}
private void init() {
if (isThrowable()) {
TypeMirror returnType = this.returnType;
if (ElementHelper.isAnnotatedWith(method.reference(), ConstructType.class)) {
final TypeElement constructTypeValue = ElementHelper.getClassAnnotationValue(method.reference(), ConstructType.class);
// Shouldn't be null
if (constructTypeValue == null) {
throw new ProcessingException(method.reference(), "Class not defined for the ConstructType");
}
returnType = constructTypeValue.asType();
if (!types.isAssignable(returnType, this.returnType)) {
throw new ProcessingException(method.reference(), "The requested type %s can not be assigned to %s.", returnType, this.returnType);
}
}
throwableType = ThrowableTypeFactory.forReturnType(elements, types, returnType, method);
}
final Element e = types.asElement(returnType);
if (e instanceof TypeElement) {
final List returnTypeMethods = ElementFilter.methodsIn(elements.getAllMembers((TypeElement) e));
for (ExecutableElement executableElement : returnTypeMethods) {
if (executableElement.getModifiers().contains(Modifier.PUBLIC) && executableElement.getParameters().size() == 1) {
methods.put(executableElement.getSimpleName().toString(), executableElement.getParameters().get(0).asType());
}
}
for (Element element : ElementFilter.fieldsIn(elements.getAllMembers((TypeElement) e))) {
if (element.getModifiers().contains(Modifier.PUBLIC) && !element.getModifiers().contains(Modifier.FINAL)) {
fields.put(element.getSimpleName().toString(), element.asType());
}
}
}
}
@Override
public int hashCode() {
return HashCodeBuilder.builder().add(name()).toHashCode();
}
@Override
public boolean equals(final Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof AptReturnType)) {
return false;
}
final AptReturnType other = (AptReturnType) obj;
return areEqual(name(), other.name());
}
@Override
public String toString() {
return Objects.ToStringBuilder.of(this)
.add("name", name())
.add("primitive", isPrimitive())
.add("throwable", isThrowable())
.add("throwableType", throwableType).toString();
}
@Override
public TypeMirror reference() {
return returnType;
}
private boolean checkType(final Parameter parameter, final TypeMirror type) {
if (parameter.isPrimitive()) {
if (type.getKind().isPrimitive()) {
return parameter.type().equalsIgnoreCase(type.getKind().name());
}
return types.isAssignable(elements.getTypeElement(unbox(parameter)).asType(), type);
}
if (type.getKind().isPrimitive()) {
final TypeElement primitiveType = types.boxedClass((PrimitiveType) type);
return types.isAssignable(elements.getTypeElement(parameter.type()).asType(), primitiveType.asType());
}
return types.isAssignable(elements.getTypeElement(parameter.type()).asType(), type);
}
private String unbox(final Parameter parameter) {
String result = parameter.type();
if (parameter.isPrimitive()) {
if ("int".equals(result)) {
result = Integer.class.getName();
} else if ("char".equals(result)) {
result = Character.class.getName();
} else {
result = "java.lang." + Character.toUpperCase(result.charAt(0)) + result.substring(1);
}
}
return result;
}
}
}
ThrowableTypeFactory.java 0000664 0000000 0000000 00000032361 12551760010 0036166 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/jboss/logging/processor/apt /*
* JBoss, Home of Professional Open Source.
* Copyright 2012, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.logging.processor.apt;
import static org.jboss.logging.processor.model.Parameter.ParameterType;
import static org.jboss.logging.processor.util.Objects.HashCodeBuilder;
import static org.jboss.logging.processor.util.Objects.areEqual;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.util.ElementFilter;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
import org.jboss.logging.processor.model.MessageMethod;
import org.jboss.logging.processor.model.Parameter;
import org.jboss.logging.processor.model.ThrowableType;
import org.jboss.logging.processor.util.Objects;
/**
* Describes information about the return type.
*
* @author James R. Perkins
*/
final class ThrowableTypeFactory {
private ThrowableTypeFactory() {
}
/**
* Creates a new descriptor that is not primitive.
*
* @param elements the element utilities from the annotation processor.
* @param types the type utilities from the annotation process.
* @param type the class name of the return type.
* @param messageMethod the message method.
*
* @return the return type descriptor.
*/
public static ThrowableType forReturnType(final Elements elements, final Types types, final TypeMirror type, final MessageMethod messageMethod) {
final AptReturnThrowableType result = new AptReturnThrowableType(elements, types, messageMethod, type);
result.init();
return result;
}
/**
* Creates a new descriptor that is not primitive.
*
* @param elements the element utilities from the annotation processor.
* @param types the type utilities from the annotation process.
* @param type the class name of the return type.
*
* @return the return type descriptor.
*/
public static ThrowableType of(final Elements elements, final Types types, final TypeMirror type) {
final AptThrowableType result = new AptThrowableType(elements, types, type);
result.init();
return result;
}
private static class AptThrowableType extends AbstractMessageObjectType implements ThrowableType {
private final TypeMirror type;
private final boolean isChecked;
private boolean defaultConstructor = false;
private boolean stringConstructor = false;
private boolean throwableConstructor = false;
private boolean stringAndThrowableConstructor = false;
private boolean throwableAndStringConstructor = false;
protected final TypeMirror stringType;
protected final TypeMirror throwableType;
/**
* Creates a new descriptor that is not primitive.
*
* @param types the type utilities from the annotation processor.
* @param elements the element utilities from the annotation processor.
* @param type the class name of the return type.
*/
private AptThrowableType(final Elements elements, final Types types, final TypeMirror type) {
super(elements, types, type);
this.type = type;
stringType = elements.getTypeElement(String.class.getName()).asType();
throwableType = elements.getTypeElement(Throwable.class.getName()).asType();
final TypeMirror runtimeException = elements.getTypeElement(RuntimeException.class.getName()).asType();
final TypeMirror error = elements.getTypeElement(Error.class.getName()).asType();
isChecked = !(types.isAssignable(runtimeException, type) && types.isAssignable(error, type));
}
/**
* Initializes the object.
*/
protected final void init() {
if (!type.getKind().isPrimitive() && type.getKind() != TypeKind.VOID) {
final Element element = types.asElement(type);
final List constructors = ElementFilter.constructorsIn(element.getEnclosedElements());
for (ExecutableElement constructor : constructors) {
// Only allow public constructors
if (!constructor.getModifiers().contains(Modifier.PUBLIC)) {
continue;
}
final List params = constructor.getParameters();
switch (params.size()) {
case 0:
defaultConstructor = true;
break;
case 1:
if (types.isAssignable(stringType, params.get(0).asType())) {
stringConstructor = true;
} else if (types.isAssignable(params.get(0).asType(), throwableType)) {
throwableConstructor = true;
}
break;
case 2:
if (types.isAssignable(stringType, params.get(0).asType())
&& types.isAssignable(params.get(1).asType(), throwableType)) {
stringAndThrowableConstructor = true;
} else if (types.isAssignable(params.get(0).asType(), throwableType)
&& types.isAssignable(stringType, params.get(1).asType())) {
throwableAndStringConstructor = true;
}
break;
}
init(params);
}
}
}
/**
* Allows for additional processing of parameters.
*
* @param params the parameters to be processed.
*/
protected void init(final List params) {
}
@Override
public boolean hasDefaultConstructor() {
return defaultConstructor;
}
@Override
public boolean hasStringAndThrowableConstructor() {
return stringAndThrowableConstructor;
}
@Override
public boolean hasStringConstructor() {
return stringConstructor;
}
@Override
public boolean hasThrowableAndStringConstructor() {
return throwableAndStringConstructor;
}
@Override
public boolean hasThrowableConstructor() {
return throwableConstructor;
}
@Override
public boolean useConstructionParameters() {
return false;
}
@Override
public Set constructionParameters() {
return Collections.emptySet();
}
@Override
public boolean isChecked() {
return isChecked;
}
@Override
public String name() {
return type.toString();
}
@Override
public int hashCode() {
return HashCodeBuilder.builder().add(type).toHashCode();
}
@Override
public boolean equals(final Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof AptThrowableType)) {
return false;
}
final AptThrowableType other = (AptThrowableType) obj;
return areEqual(this.type, other.type);
}
@Override
public String toString() {
return Objects.ToStringBuilder.of(this)
.add("type", type)
.add("stringConstructor", stringConstructor)
.add("throwableConstructor", throwableConstructor)
.add("stringAndThrowableConstructor", stringAndThrowableConstructor)
.add("throwableAndStringConstructor", throwableAndStringConstructor).toString();
}
@Override
public TypeMirror reference() {
return type;
}
@Override
public int compareTo(final ThrowableType o) {
return name().compareTo(o.name());
}
}
private static class AptReturnThrowableType extends AptThrowableType {
private final MessageMethod messageMethod;
private final Set constructionParameters;
private boolean useConstructionParameters = false;
/**
* Creates a new descriptor that is not primitive.
*
* @param types the type utilities from the annotation processor.
* @param elements the element utilities from the annotation processor.
* @param messageMethod the message method.
* @param type the class name of the return type.
*/
private AptReturnThrowableType(final Elements elements, final Types types, final MessageMethod messageMethod, final TypeMirror type) {
super(elements, types, type);
this.messageMethod = messageMethod;
constructionParameters = new LinkedHashSet();
}
@Override
protected void init(final List params) {
final Set methodConstructorParameters = messageMethod.parameters(ParameterType.CONSTRUCTION);
// If there are no construction parameters or a constructor was already found, no need to process
if (methodConstructorParameters.isEmpty() || useConstructionParameters) {
return;
}
// The number of parameters needed has to include the cause, if specified, and the message it self
final int neededParamSize = methodConstructorParameters.size() + (messageMethod.hasCause() ? 2 : 1);
if (neededParamSize == params.size()) {
// Checks for the first constructor that can be used. The compiler will end-up determining the constructor
// to use, so a best guess should work.
final Iterator methodParameterIterator = methodConstructorParameters.iterator();
final Set matchedParams = new LinkedHashSet();
boolean match = false;
boolean causeFound = false;
boolean messageFound = false;
for (VariableElement param : params) {
if (!causeFound && messageMethod.hasCause() && types.isAssignable(throwableType, param.asType())) {
causeFound = true;
matchedParams.add(messageMethod.cause());
continue;
}
if (!messageFound && types.isAssignable(param.asType(), stringType)) {
messageFound = true;
matchedParams.add(ParameterFactory.forMessageMethod(messageMethod));
continue;
}
if (methodParameterIterator.hasNext()) {
final Parameter parameter = methodParameterIterator.next();
if (parameter.reference() instanceof VariableElement) {
final VariableElement refType = (VariableElement) parameter.reference();
match = types.isAssignable(refType.asType(), param.asType());
}
if (match) {
matchedParams.add(parameter);
}
}
// Short circuit
if (!match) break;
}
if (match) {
constructionParameters.clear();
useConstructionParameters = true;
constructionParameters.addAll(matchedParams);
}
}
}
@Override
public boolean useConstructionParameters() {
return useConstructionParameters;
}
@Override
public Set constructionParameters() {
return constructionParameters;
}
}
}
ToolLogger.java 0000664 0000000 0000000 00000027405 12551760010 0034125 0 ustar 00root root 0000000 0000000 jboss-logging-tools-2.0.1.Final/processor/src/main/java/org/jboss/logging/processor/apt /*
* JBoss, Home of Professional Open Source.
* Copyright 2012, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.logging.processor.apt;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.Element;
import javax.tools.Diagnostic.Kind;
/**
* A logger for logging messages for annotation processors.
*
* @author James R. Perkins
* @author Kevin Pollet - SERLI - (kevin.pollet@serli.com)
*/
public final class ToolLogger {
private final Messager messager;
private final boolean isDebugEnabled;
private ToolLogger(final Messager messager, final boolean isDebugEnabled) {
this.messager = messager;
this.isDebugEnabled = isDebugEnabled;
}
/**
* Creates a new tool logger.
*
* @param processingEnv the processing environment
*
* @return a new tool logger
*/
public static ToolLogger getLogger(final ProcessingEnvironment processingEnv) {
String debug = processingEnv.getOptions().get(LoggingToolsProcessor.DEBUG_OPTION);
boolean isDebugEnabled = Boolean.parseBoolean(debug);
return new ToolLogger(processingEnv.getMessager(), isDebugEnabled);
}
/**
* Returns {@code true} if debugging is enabled, otherwise {@code false}.
*
* It is not necessary to invoke this method before invoking {@code debug}
* methods. The debug methods will only log messages if debugging is
* enabled.
*
*
* @return {@code true} if debugging is enabled, otherwise {@code false}.
*/
public boolean isDebugEnabled() {
return isDebugEnabled;
}
/**
* Prints a note message.
*
* @param element the element to print with the note.
* @param message the message.
*/
public void note(final Element element, final String message) {
log(Kind.NOTE, element, message);
}
/**
* Prints a formatted note message.
*
* @param element the element to print with the note.
* @param messageFormat the message format.
* @param args the format arguments.
*/
public void note(final Element element, final String messageFormat, final Object... args) {
log(Kind.NOTE, element, messageFormat, args);
}
/**
* Prints a formatted debug message if debugging is enabled.
*
* @param messageFormat the message format.
* @param args the format arguments.
*/
public void debug(final String messageFormat, final Object... args) {
if (isDebugEnabled) {
debug(null, messageFormat, args);
}
}
/**
* Prints a debug message.
*
* @param element the element to print with the note.
* @param message the message.
*/
public void debug(final Element element, final String message) {
if (isDebugEnabled) {
other(element, message);
}
}
/**
* Prints a formatted debug message if debugging is enabled.
*
* @param element the element to print with the note.
* @param messageFormat the message format.
* @param args the format arguments.
*/
public void debug(final Element element, final String messageFormat, final Object... args) {
if (isDebugEnabled) {
other(null, messageFormat, element, args);
}
}
/**
* Prints a warning message.
*
* @param element the element to print with the message.
* @param message the message.
*/
public void warn(final Element element, final String message) {
log(Kind.WARNING, element, message);
}
/**
* Prints a formatted warning message.
*
* @param element the element that caused the warning.
* @param messageFormat the message format.
* @param args the format arguments.
*/
public void warn(final Element element, final String messageFormat, final Object... args) {
log(Kind.WARNING, element, messageFormat, args);
}
/**
* Prints a warning message.
*
* @param element the element to print with the message.
* @param message the message.
*/
public void mandatoryWarning(final Element element, final String message) {
log(Kind.MANDATORY_WARNING, element, message);
}
/**
* Prints a formatted warning message.
*
* @param element the element that caused the warning.
* @param messageFormat the message format.
* @param args the format arguments.
*/
public void mandatoryWarning(final Element element, final String messageFormat, final Object... args) {
log(Kind.MANDATORY_WARNING, element, messageFormat, args);
}
/**
* Prints a formatted error message.
*
* @param messageFormat the message format.
* @param args the format arguments.
*/
public void error(final String messageFormat, final Object... args) {
log(Kind.ERROR, null, messageFormat, args);
}
/**
* Prints a error message.
*
* @param element the element to print with the message.
* @param message the message.
*/
public void error(final Element element, final String message) {
log(Kind.ERROR, element, message);
}
/**
* Prints a formatted error message.
*
* @param messageFormat the message format.
* @param element the element that caused the warning.
* @param args the format arguments.
*/
public void error(final Element element, final String messageFormat, final Object... args) {
log(Kind.ERROR, element, messageFormat, args);
}
/**
* Prints an error message.
*
* @param cause the cause of the error.
*/
public void error(final Throwable cause) {
error(null, cause);
}
/**
* Prints a error message.
*
* @param cause the cause of the error.
* @param element the element to print with the message.
* @param message the message.
*/
public void error(final Throwable cause, final Element element, final String message) {
log(Kind.ERROR, element, cause, message);
}
/**
* Prints an error message.
*
* @param cause the cause of the error.
* @param messageFormat the message format.
* @param args the format arguments.
*/
public void error(final Throwable cause, final String messageFormat, final Object... args) {
error(null, cause, messageFormat, args);
}
/**
* Prints an error message.
*
* @param cause the cause of the error.
* @param element the element that caused the error.
*/
public void error(final Element element, final Throwable cause) {
log(Kind.ERROR, element, cause, null);
}
/**
* Prints an error message.
*
* @param cause the cause of the error.
* @param messageFormat the message format.
* @param element the element that caused the warning.
* @param args the format arguments.
*/
public void error(final Element element, final Throwable cause, final String messageFormat, final Object... args) {
log(Kind.ERROR, element, cause, messageFormat, args);
}
/**
* Prints a message that does not fit the other types.
*
* @param element the element to print with the message.
* @param message the message.
*/
public void other(final Element element, final String message) {
log(Kind.OTHER, element, message);
}
/**
* Prints a formatted message that does not fit the other types.
*
* @param element the element to print with the note.
* @param messageFormat the message format.
* @param args the format arguments.
*/
public void other(final Element element, final String messageFormat, final Object... args) {
log(Kind.OTHER, element, messageFormat, args);
}
private void log(final Kind kind, final Element element, final String message) {
if (element == null) {
messager.printMessage(kind, message);
} else {
messager.printMessage(kind, message, element);
}
}
private void log(final Kind kind, final Element element, final String messageFormat, final Object... args) {
try {
String message = ((args == null || args.length == 0) ? messageFormat : String.format(messageFormat, args));
if (element == null) {
messager.printMessage(kind, message);
} else {
messager.printMessage(kind, message, element);
}
// Fail gracefully
} catch (Throwable t) {
if (element == null) {
messager.printMessage(Kind.ERROR, "Error logging original message: " + messageFormat);
} else {
messager.printMessage(Kind.ERROR, "Error logging original message: " + messageFormat, element);
}
}
}
private void log(final Kind kind, final Element element, final Throwable cause, final String messageFormat, final Object... args) {
String stringCause = stackTraceToString(cause);
if (messageFormat == null) {
log(kind, element, stringCause);
} else {
String messageWithCause = messageFormat.concat(", cause : %s");
List