1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
/*******************************************************************************
* Copyright (c) 2005, 2010 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* mkaufman@bea.com - initial API as ICompilationParticipant
* IBM - changed from interface ICompilationParticipant to abstract class CompilationParticipant
* IBM - rewrote specification
*
*******************************************************************************/
package org.eclipse.jdt.core.compiler;
import org.eclipse.jdt.core.IJavaProject;
/**
* A compilation participant is notified of events occurring during the compilation process.
* The compilation process not only involves generating .class files (i.e. building), it also involves
* cleaning the output directory, reconciling a working copy, etc.
* So the notified events are the result of a build action, a clean action, a reconcile operation
* (for a working copy), etc.
* <p>
* Code that participates in the build should in general be implemented with a separate Builder,
* rather than a CompilationParticipant. It is only necessary to use a CompilationParticipant if
* the build step needs to interact with the Java build, for instance by creating additional
* Java source files that must themselves in turn be compiled.
* <p>
* Clients wishing to participate in the compilation process must subclass this class, and implement
* {@link #isActive(IJavaProject)}, {@link #aboutToBuild(IJavaProject)},
* {@link #reconcile(ReconcileContext)}, etc.
* </p><p>
* This class is intended to be subclassed by clients.
* </p>
* @since 3.2
*/
public abstract class CompilationParticipant {
public final static int READY_FOR_BUILD = 1;
public final static int NEEDS_FULL_BUILD = 2;
/**
* Notifies this participant that a build is about to start and provides it the opportunity to
* create missing source folders for generated source files. Additional source folders
* should be marked as optional so the project can be built when the folders do not exist.
* Only sent to participants interested in the project.
* <p>
* Default is to return <code>READY_FOR_BUILD</code>.
* </p>
* @see #buildFinished(IJavaProject project)
* @param project the project about to build
* @return READY_FOR_BUILD or NEEDS_FULL_BUILD
*/
public int aboutToBuild(IJavaProject project) {
return READY_FOR_BUILD;
}
/**
* Notifies this participant that a build has finished for the project.
* This will be sent, even if buildStarting() was not sent when no source files needed to be compiled
* or the build failed.
* Only sent to participants interested in the project.
* @param project the project about to build
* @since 3.4
*/
public void buildFinished(IJavaProject project) {
// do nothing by default
}
/**
* Notifies this participant that a compile operation is about to start and provides it the opportunity to
* generate source files based on the source files about to be compiled.
* When isBatchBuild is true, then files contains all source files in the project.
* Only sent to participants interested in the current build project.
*
* @param files is an array of BuildContext
* @param isBatch identifies when the build is a batch build
*/
public void buildStarting(BuildContext[] files, boolean isBatch) {
// do nothing by default
}
/**
* Notifies this participant that a clean is about to start and provides it the opportunity to
* delete generated source files.
* Only sent to participants interested in the project.
* @param project the project about to be cleaned
*/
public void cleanStarting(IJavaProject project) {
// do nothing by default
}
/**
* Returns whether this participant is active for a given project.
* <p>
* Default is to return <code>false</code>.
* </p><p>
* For efficiency, participants that are not interested in the
* given project should return <code>false</code> for that project.
* </p>
* @param project the project to participate in
* @return whether this participant is active for a given project
*/
public boolean isActive(IJavaProject project) {
return false;
}
/**
* Returns whether this participant is interested in only Annotations.
* <p>
* Default is to return <code>false</code>.
* </p>
* @return whether this participant is interested in only Annotations.
*/
public boolean isAnnotationProcessor() {
return false;
}
/**
* Notifies this participant that a compile operation has found source files using Annotations.
* Only sent to participants interested in the current build project that answer true to isAnnotationProcessor().
* Each BuildContext was informed whether its source file currently hasAnnotations().
*
* @param files is an array of BuildContext
*/
public void processAnnotations(BuildContext[] files) {
// do nothing by default
}
/**
* Notifies this participant that a reconcile operation is happening. The participant can act on this reconcile
* operation by using the given context. Other participant can then see the result of this participation
* on this context.
* <p>
* Note that a participant should not modify the buffer of the working copy that is being reconciled.
* </p><p>
* Default is to do nothing.
* </p>
* @param context the reconcile context to act on
*/
public void reconcile(ReconcileContext context) {
// do nothing by default
}
}
|
