youys
/
ant
Not watched
1
0
Fork 1
Code
Releases 0 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

remove apt task, there is no apt tool in java8

master
Stefan Bodewig 9 years ago
parent
3c930b9323
commit
afdf355c65
12 changed files with 3 additions and 894 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +3
    -0
      WHATSNEW
  2. +0
    -179
      manual/Tasks/apt.html
  3. +0
    -1
      manual/tasklist.html
  4. +0
    -6
      manual/tasksoverview.html
  5. +0
    -270
      src/main/org/apache/tools/ant/taskdefs/Apt.java
  6. +0
    -187
      src/main/org/apache/tools/ant/taskdefs/compilers/AptCompilerAdapter.java
  7. +0
    -71
      src/main/org/apache/tools/ant/taskdefs/compilers/AptExternalCompilerAdapter.java
  8. +0
    -1
      src/main/org/apache/tools/ant/taskdefs/defaults.properties
  9. +0
    -25
      src/tests/antunit/taskdefs/apt/AptExample.java
  10. +0
    -39
      src/tests/antunit/taskdefs/apt/Distributed.java
  11. +0
    -50
      src/tests/antunit/taskdefs/apt/DistributedAnnotationFactory.java
  12. +0
    -65
      src/tests/antunit/taskdefs/apt/DistributedAnnotationProcessor.java

+ 3
- 0
WHATSNEW View File

@@ -7,6 +7,9 @@ Changes that could break older environments:
* Ant 1.10.x requires Java8 or newer at compile or build time.
The 1.9.x series wil stay compatible with Java5.

* The <apt> task has been removed since apt itself has been removed
with Java8.

Fixed bugs:
-----------



+ 0
- 179
manual/Tasks/apt.html View File

@@ -1,179 +0,0 @@
<!--
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<html lang="en-us"><head>
<meta http-equiv="Content-Language" content="en-us"><link rel="stylesheet" type="text/css" href="../stylesheets/style.css">
<title>Apt Task</title></head>

<body>

<h2><a name="Apt">Apt</a></h2>
<h3>Description</h3>
<p>Runs the annotation processor tool (apt), and then optionally compiles
the original code, and any generated source code.
<p>This task runs on Java 1.5 to Java 1.7.</p>
<p>Apt is deprecated in Java 1.6, which can run annotation
processors as part of javac, and removed from the distribution in Java 1.8.
The task will fire an exception when attempting to run under Java 1.8.</p>


<p>This task inherits from the <a href="javac.html">Javac Task</a>, and thus
supports nearly all of the same attributes, and subelements.
There is one special case, the <tt>fork</tt> attribute, which is present
but which can only be set to <tt>true</tt>. That is, apt only works as
a forked process.
</p>
<p>
In addition, it supports
the following addition items:</p>

<h3>Parameters</h3>
<table border="1" cellpadding="2" cellspacing="0">
<tbody><tr>
<td valign="top"><b>Attribute</b></td>
<td valign="top"><b>Description</b></td>
<td align="center" valign="top"><b>Required</b></td>
</tr>
<tr>
<td valign="top">compile</td>
<td valign="top">After running the Apt, should the code be compiled. (see the
<code>-nocompile</code> flag on the Apt executable)</td>
<td align="center" valign="top">No, defaults to false.</td>
</tr>
<tr>
<td valign="top">factory</td>
<td valign="top">The fully qualified classname of the AnnotationProcessFactory to be used
to construct annotation processors. This represents the <code>-factory</code>
command line flag of the Apt executable.</td>
<td align="center" valign="top">No</td>
</tr>
<tr>
<td valign="top">factorypathref</td>
<td valign="top">The reference id of the path used to find the classes needed by the
AnnotationProcessorFactory (and the location of the factory itself).
This represents the <code>-factorypath</code> flag on the Apt executable.</td>
<td align="center" valign="top">No</td>
</tr>
<tr>
<td valign="top">preprocessdir</td>
<td valign="top">The directory used for preprocessing. This is the directory where the
generated source code will be place. This represents the <code>-s</code> flag on
the Apt executable.</td>
<td align="center" valign="top">No</td>
</tr>
</tbody></table>

<h3>Parameters specified as nested elements</h3>


<h4>factorypath</h4>

<p>You can specify the path used to find the classes needed by the AnnotationProcessorFactory
at runtime, using this element. It is represents as a generic path like structure. This
represents the <code>-factorypath</code> flag on the Apt executable.</p>


<h4>option</h4>

<p>Used to represent a generic option to pass to Apt. This represents the <code>-A</code> flag on the
Apt executable. You can specify zero or more <code>&lt;option&gt;</code> elements.</p>

<table border="1" cellpadding="2" cellspacing="0">
<tbody><tr>
<td valign="top" width="12%"><b>Attribute</b></td>
<td valign="top" width="78%"><b>Description</b></td>
<td valign="top" width="10%"><b>Required</b></td>
</tr>
<tr>
<td valign="top">name</td>
<td align="center">The name of the option</td>
<td align="center">Yes.</td>
</tr>
<tr>
<td valign="top">value</td>
<td align="center">The value to set the option to</td>
<td align="center">Yes.</td>
</tr>
</tbody></table>

<h3>Examples</h3>
<blockquote><pre>
&lt;apt srcdir="${src}"
destdir="${build}"
classpath="xyz.jar"
debug="on"
compile="true"
factory="com.mycom.MyAnnotationProcessorFactory"
factorypathref="my.factorypath.id"
preprocessdir="${preprocess.dir}"&gt;
&lt;/apt&gt;
</pre></blockquote>
<p>compiles all <code>.java</code> files under the <code>${src}</code>
directory, and stores
the <code>.class</code> files in the <code>${build}</code> directory.
The classpath used includes <code>xyz.jar</code>, and compiling with
debug information is on. It also forces the generated source code to
be compiled. The generated source code will be placed in
<code>${preprocess.dir}</code> directory, using the class
<code>com.mycom.MyAnnotationProcessorFactory</code> to supply
AnnotationProcessor instances.</p>


<h3>Notes</h3>

<p>
The inherited "fork" attribute is set to true by default; please do not change it.
</p>

<p>
The inherited "compiler" attribute is ignored, as it is forced to use the Apt compiler
</p>

<p>Using the Apt compiler with the "compile" option set to "true"
forces you to use Sun's Apt compiler, which will use the JDK's Javac compiler.
If you wish to use another compiler, you will first need run the Apt processor
with the "compile" flag set to "false", and then use a
<code>&lt;javac&gt;</code> task to compile first your original source code, and then the
generated source code:</p>

<blockquote><pre>
&lt;apt srcdir="${src}"
destdir="${build}"
classpath="xyz.jar"
debug="true"
compile="false"
factory="com.mycom.MyAnnotationProcessorFactory"
factorypathref="my.factorypath.id"
preprocessdir="${preprocess.dir}"&gt;
&lt;/apt&gt;

&lt;javac srcdir="${src}"
destdir="${build}"
classpath="xyz.jar"
debug="on"/&gt;

&lt;javac srcdir="${preprocess.dir}"
destdir="${build}"
classpath="xyz.jar"
debug="true"/&gt;
</pre></blockquote>

This may involve more build file coding, but the speedup gained from switching
to jikes may justify the effort.
<p>
</p>

</body></html>

+ 0
- 1
manual/tasklist.html View File

@@ -40,7 +40,6 @@
<li><a href="Tasks/antstructure.html">AntStructure</a></li>
<li><a href="Tasks/antversion.html">AntVersion</a></li>
<li><a href="Tasks/apply.html">Apply/<i>ExecOn</i></a></li>
<li><a href="Tasks/apt.html">Apt</a></li>
<li><a href="Tasks/attrib.html">Attrib</a></li>
<li><a href="Tasks/augment.html">Augment</a></li>
<li><a href="Tasks/available.html">Available</a></li>


+ 0
- 6
manual/tasksoverview.html View File

@@ -231,12 +231,6 @@ documentation.</p>
specified.</p></td>
</tr>

<tr valign="top">
<td nowrap><a href="Tasks/apt.html">Apt</a></td>
<td><p>Runs the annotation processor tool (apt), and then optionally compiles
the original code, and any generated source code.</p></td>
</tr>

<tr valign="top">
<td nowrap><a href="Tasks/jspc.html">JspC</a></td>
<td><p>Runs the JSP compiler. It can be used to precompile JSP pages


+ 0
- 270
src/main/org/apache/tools/ant/taskdefs/Apt.java View File

@@ -1,270 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.apache.tools.ant.taskdefs;

import java.io.File;
import java.util.Vector;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.compilers.AptExternalCompilerAdapter;
import org.apache.tools.ant.types.Path;
import org.apache.tools.ant.types.Reference;
import org.apache.tools.ant.util.JavaEnvUtils;

/**
* Apt Task for running the Annotation processing tool for JDK 1.5. It derives
* from the existing Javac task, and forces the compiler based on whether we're
* executing internally, or externally.
*
* @since Ant 1.7
*/


public class Apt
extends Javac {
private boolean compile = true;
private String factory;
private Path factoryPath;
private Vector<Option> options = new Vector<Option>();
private File preprocessDir;
/** The name of the apt tool. */
public static final String EXECUTABLE_NAME = "apt";
/** An warning message when ignoring compiler attribute. */
public static final String ERROR_IGNORING_COMPILER_OPTION
= "Ignoring compiler attribute for the APT task, as it is fixed";
/** A warning message if used with java &lt; 1.5. */
public static final String ERROR_WRONG_JAVA_VERSION
= "Apt task requires Java 1.5+";

/**
* exposed for debug messages
*/
public static final String WARNING_IGNORING_FORK =
"Apt only runs in its own JVM; fork=false option ignored";

/**
* The nested option element.
*/
public static final class Option {
private String name;
private String value;

/** Constructor for Option */
public Option() {
//default
}

/**
* Get the name attribute.
* @return the name attribute.
*/
public String getName() {
return name;
}

/**
* Set the name attribute.
* @param name the name of the option.
*/
public void setName(String name) {
this.name = name;
}

/**
* Get the value attribute.
* @return the value attribute.
*/
public String getValue() {
return value;
}

/**
* Set the value attribute.
* @param value the value of the option.
*/
public void setValue(String value) {
this.value = value;
}
}

/**
* Constructor for Apt task.
* This sets the apt compiler adapter as the compiler in the super class.
*/
public Apt() {
super();
super.setCompiler(AptExternalCompilerAdapter.class.getName());
super.setFork(true);
}

/**
* Get the name of the apt executable.
*
* @return the name of the executable.
*/
public String getAptExecutable() {
String exe = getExecutable();
return exe != null ? exe :
JavaEnvUtils.getJdkExecutable(EXECUTABLE_NAME);
}

/**
* Set the compiler.
* This is not allowed and a warning log message is made.
* @param compiler not used.
*/
public void setCompiler(String compiler) {
log(ERROR_IGNORING_COMPILER_OPTION, Project.MSG_WARN);
}

/**
* Set the fork attribute.
* Non-forking APT is highly classpath dependent and appears to be too
* brittle to work. The sole reason this attribute is retained
* is the superclass does it
* @param fork if false; warn the option is ignored.
*/
public void setFork(boolean fork) {
if (!fork) {
log(WARNING_IGNORING_FORK, Project.MSG_WARN);
}
}

/**
* Get the compiler class name.
* @return the compiler class name.
*/
public String getCompiler() {
return super.getCompiler();
}

/**
* Get the compile option for the apt compiler.
* If this is false the "-nocompile" argument will be used.
* @return the value of the compile option.
*/
public boolean isCompile() {
return compile;
}

/**
* Set the compile option for the apt compiler.
* Default value is true.
* @param compile if true set the compile option.
*/
public void setCompile(boolean compile) {
this.compile = compile;
}

/**
* Get the factory option for the apt compiler.
* If this is non-null the "-factory" argument will be used.
* @return the value of the factory option.
*/
public String getFactory() {
return factory;
}

/**
* Set the factory option for the apt compiler.
* Default value is null.
* @param factory the classname of the factory.
*/
public void setFactory(String factory) {
this.factory = factory;
}

/**
* Add a reference to a path to the factoryPath attribute.
* @param ref a reference to a path.
*/
public void setFactoryPathRef(Reference ref) {
createFactoryPath().setRefid(ref);
}

/**
* Add a path to the factoryPath attribute.
* @return a path to be configured.
*/
public Path createFactoryPath() {
if (factoryPath == null) {
factoryPath = new Path(getProject());
}
return factoryPath.createPath();
}

/**
* Get the factory path attribute.
* If this is not null, the "-factorypath" argument will be used.
* The default value is null.
* @return the factory path attribute.
*/
public Path getFactoryPath() {
return factoryPath;
}

/**
* Create a nested option.
* @return an option to be configured.
*/
public Option createOption() {
Option opt = new Option();
options.add(opt);
return opt;
}

/**
* Get the options to the compiler.
* Each option will use '"-E" name ["=" value]' argument.
* @return the options.
*/
public Vector<Option> getOptions() {
return options;
}

/**
* Get the preprocessdir attribute.
* This corresponds to the "-s" argument.
* The default value is null.
* @return the preprocessdir attribute.
*/
public File getPreprocessDir() {
return preprocessDir;
}

/**
* Set the preprocessdir attribute.
* @param preprocessDir where to place processor generated source files.
*/
public void setPreprocessDir(File preprocessDir) {
this.preprocessDir = preprocessDir;
}

/**
* Do the compilation.
* @throws BuildException on error.
*/
public void execute()
throws BuildException {
if (JavaEnvUtils.getJavaVersionNumber() >= 18) {
throw new BuildException("apt does not exist under Java 1.8 and higher");
}
super.execute();
}
}

+ 0
- 187
src/main/org/apache/tools/ant/taskdefs/compilers/AptCompilerAdapter.java View File

@@ -1,187 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/

package org.apache.tools.ant.taskdefs.compilers;

import java.io.File;
import java.lang.reflect.Method;
import java.util.Enumeration;
import java.util.Vector;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.Apt;
import org.apache.tools.ant.types.Commandline;
import org.apache.tools.ant.types.Path;


/**
* <p>The implementation of the apt compiler for JDK 1.5.</p>
*
* <p>As usual, the low level entry points for Java tools are neither documented or
* stable; this entry point may change from that of 1.5.0_01-b08 without any
* warning at all. The IDE decompile of the tool entry points is as follows:</p>
* <pre>
* public class Main {
* public Main() ;
*
* public static transient void main(String... strings);
*
* public static transient int process(String... strings);
*
* public static transient int process(PrintWriter printWriter,
* String... strings);
* public static transient int process(
* AnnotationProcessorFactory annotationProcessorFactory,
* String... strings);
*
* public static transient int process(
* AnnotationProcessorFactory annotationProcessorFactory,
* PrintWriter printWriter,
* String... strings);
* private static transient int processing(
* AnnotationProcessorFactory annotationProcessorFactory,
* PrintWriter printWriter,
* String... strings) ;
* }
* </pre>
*
* This Adapter is designed to run Apt in-JVM, an option that is not actually
* exposed to end-users, because it was too brittle during beta testing; classpath
* problems being the core issue.
*
* @since Ant 1.7
*/
public class AptCompilerAdapter extends DefaultCompilerAdapter {

/**
* Integer returned by the Apt compiler to indicate success.
*/
private static final int APT_COMPILER_SUCCESS = 0;
/**
* class in tools.jar that implements APT
*/
public static final String APT_ENTRY_POINT = "com.sun.tools.apt.Main";

/**
* method used to compile.
*/
public static final String APT_METHOD_NAME = "process";

/**
* Get the facade task that fronts this adapter
*
* @return task instance
* @see DefaultCompilerAdapter#getJavac()
*/
protected Apt getApt() {
return (Apt) getJavac();
}

/**
* Using the front end arguments, set up the command line to run Apt
*
* @param apt task
* @param cmd command that is set up with the various switches from the task
* options
*/
static void setAptCommandlineSwitches(final Apt apt, final Commandline cmd) {

if (!apt.isCompile()) {
cmd.createArgument().setValue("-nocompile");
}

// Process the factory class
final String factory = apt.getFactory();
if (factory != null) {
cmd.createArgument().setValue("-factory");
cmd.createArgument().setValue(factory);
}

// Process the factory path
final Path factoryPath = apt.getFactoryPath();
if (factoryPath != null) {
cmd.createArgument().setValue("-factorypath");
cmd.createArgument().setPath(factoryPath);
}

final File preprocessDir = apt.getPreprocessDir();
if (preprocessDir != null) {
cmd.createArgument().setValue("-s");
cmd.createArgument().setFile(preprocessDir);
}

// Process the processor options
final Vector options = apt.getOptions();
final Enumeration elements = options.elements();
Apt.Option opt;
StringBuffer arg = null;
while (elements.hasMoreElements()) {
opt = (Apt.Option) elements.nextElement();
arg = new StringBuffer();
arg.append("-A").append(opt.getName());
if (opt.getValue() != null) {
arg.append("=").append(opt.getValue());
}
cmd.createArgument().setValue(arg.toString());
}
}

/**
* using our front end task, set up the command line switches
*
* @param cmd command line to set up
*/
protected void setAptCommandlineSwitches(final Commandline cmd) {
final Apt apt = getApt();
setAptCommandlineSwitches(apt, cmd);
}

/**
* Run the compilation.
* @return true on success.
* @throws BuildException if the compilation has problems.
*/
public boolean execute() throws BuildException {
attributes.log("Using apt compiler", Project.MSG_VERBOSE);
//set up the javac options
final Commandline cmd = setupModernJavacCommand();
//then add the Apt options
setAptCommandlineSwitches(cmd);

//finally invoke APT
// Use reflection to be able to build on all JDKs:
try {
final Class c = Class.forName(APT_ENTRY_POINT);
final Object compiler = c.newInstance();
final Method compile = c.getMethod(APT_METHOD_NAME,
new Class[]{(new String[]{}).getClass()});
final int result = ((Integer) compile.invoke
(compiler, new Object[]{cmd.getArguments()}))
.intValue();
return (result == APT_COMPILER_SUCCESS);
} catch (final BuildException be) {
//rethrow build exceptions
throw be;
} catch (final Exception ex) {
//cast everything else to a build exception
throw new BuildException("Error starting apt compiler",
ex, location);
}
}
}

+ 0
- 71
src/main/org/apache/tools/ant/taskdefs/compilers/AptExternalCompilerAdapter.java View File

@@ -1,71 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/

package org.apache.tools.ant.taskdefs.compilers;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.Apt;
import org.apache.tools.ant.types.Commandline;

/**
* The implementation of the apt compiler for JDK 1.5 using an external process
*
* @since Ant 1.7
*/
public class AptExternalCompilerAdapter extends DefaultCompilerAdapter {


/**
* Get the facade task that fronts this adapter
*
* @return task instance
* @see DefaultCompilerAdapter#getJavac()
*/
protected Apt getApt() {
return (Apt) getJavac();
}

/**
* Performs a compile using the Javac externally.
* @return true the compilation was successful.
* @throws BuildException if there is a problem.
*/
public boolean execute() throws BuildException {
attributes.log("Using external apt compiler", Project.MSG_VERBOSE);


// Setup the apt executable
Apt apt = getApt();
Commandline cmd = new Commandline();
cmd.setExecutable(apt.getAptExecutable());
setupModernJavacCommandlineSwitches(cmd);
AptCompilerAdapter.setAptCommandlineSwitches(apt, cmd);
int firstFileName = cmd.size();
//add the files
logAndAddFilesToCompile(cmd);

//run
return 0 == executeExternalCompile(cmd.getCommandline(),
firstFileName,
true);

}

}


+ 0
- 1
src/main/org/apache/tools/ant/taskdefs/defaults.properties View File

@@ -19,7 +19,6 @@ antcall=org.apache.tools.ant.taskdefs.CallTarget
antstructure=org.apache.tools.ant.taskdefs.AntStructure
antversion=org.apache.tools.ant.taskdefs.condition.AntVersion
apply=org.apache.tools.ant.taskdefs.Transform
apt=org.apache.tools.ant.taskdefs.Apt
attributenamespacedef=org.apache.tools.ant.taskdefs.AttributeNamespaceDef
augment=org.apache.tools.ant.taskdefs.AugmentReference
available=org.apache.tools.ant.taskdefs.Available


+ 0
- 25
src/tests/antunit/taskdefs/apt/AptExample.java View File

@@ -1,25 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
/**
*/
@Distributed(
protocol="CORBA",
distribution=Distributed.DistributionTypes.FEDERATED
)
public class AptExample {
}

+ 0
- 39
src/tests/antunit/taskdefs/apt/Distributed.java View File

@@ -1,39 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
import java.lang.annotation.Annotation;
import java.lang.annotation.Target;
import java.lang.annotation.Retention;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.RetentionPolicy;

/**
*/
@Documented
@Retention(value = RetentionPolicy.RUNTIME)
@Target(value = ElementType.TYPE)
public @interface Distributed {

public DistributionTypes distribution() default DistributionTypes.LOCAL;

public String protocol() default "RMI";

public enum DistributionTypes { SINGLETON, LOCAL, FAULT_TOLERANT, FEDERATED, MOBILE};


}

+ 0
- 50
src/tests/antunit/taskdefs/apt/DistributedAnnotationFactory.java View File

@@ -1,50 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
import com.sun.mirror.apt.AnnotationProcessorFactory;
import com.sun.mirror.apt.AnnotationProcessor;
import com.sun.mirror.apt.AnnotationProcessorEnvironment;

import java.util.Collection;
import java.util.Set;
import java.util.Arrays;
import java.util.Collections;


/**
* This was the first piece of Java1.5 code in the source tree.
* @since 20050-03-09T21:29:25Z
*/
public class DistributedAnnotationFactory implements AnnotationProcessorFactory {

private static final Collection<String> supportedAnnotations
= Collections.unmodifiableCollection(Arrays.asList("*"));

public Collection<String> supportedOptions() {
return Collections.emptySet();
}

public Collection<String> supportedAnnotationTypes() {
return supportedAnnotations;
}

public AnnotationProcessor getProcessorFor(
Set<com.sun.mirror.declaration.AnnotationTypeDeclaration> annotationTypeDeclarations,
AnnotationProcessorEnvironment env) {
return new DistributedAnnotationProcessor(env);
}
}

+ 0
- 65
src/tests/antunit/taskdefs/apt/DistributedAnnotationProcessor.java View File

@@ -1,65 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/

//found in tools.jar, not the JRE runtime.
import com.sun.mirror.apt.AnnotationProcessor;
import com.sun.mirror.apt.AnnotationProcessorEnvironment;
import com.sun.mirror.declaration.TypeDeclaration;
import com.sun.mirror.declaration.ClassDeclaration;
import com.sun.mirror.util.SimpleDeclarationVisitor;
import static com.sun.mirror.util.DeclarationVisitors.*;

import java.util.Map;

/**
* Annotation processor outputs stuff
*/

public class DistributedAnnotationProcessor implements AnnotationProcessor {

public AnnotationProcessorEnvironment env;

public DistributedAnnotationProcessor(AnnotationProcessorEnvironment env) {
this.env = env;
}

public void echo(String text) {
env.getMessager().printNotice(text);
}

public void process() {
echo("DistributedAnnotationProcessor-is-go");

Map<String, String> options=env.getOptions();
for(String key:options.keySet()) {
echo("Option ["+key+"] = "+options.get(key));
}

//work time
for (TypeDeclaration typeDecl : env.getSpecifiedTypeDeclarations()) {
typeDecl.accept(getDeclarationScanner(new ClassVisitor(),
NO_OP));
}
}

private class ClassVisitor extends SimpleDeclarationVisitor {
public void visitClassDeclaration(ClassDeclaration d) {
echo("visiting "+ d.getQualifiedName());
}
}
}

Write Preview
Loading…
Cancel
Save