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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
/*******************************************************************************
* Copyright (c) 2008 Sonatype, Inc.
* 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
*******************************************************************************/
package org.eclipse.m2e.core.internal.lifecyclemapping.discovery;
import org.eclipse.m2e.core.internal.lifecyclemapping.LifecycleMappingFactory;
import org.eclipse.m2e.core.internal.lifecyclemapping.model.PluginExecutionAction;
import org.eclipse.m2e.core.internal.lifecyclemapping.model.PluginExecutionMetadata;
import org.eclipse.m2e.core.project.configurator.MojoExecutionKey;
/**
* Represents Maven plugin execution bound to project lifecycle and corresponding lifecycle mapping metadata. Only
* considers primary mapping, secondary project configurators are ignored.
*/
public class MojoExecutionMappingConfiguration implements ILifecycleMappingElement {
public static class MojoExecutionMappingRequirement implements ILifecycleMappingRequirement {
private final MojoExecutionKey execution;
public MojoExecutionMappingRequirement(MojoExecutionKey execution) {
this.execution = new MojoExecutionKey(execution.getGroupId(), execution.getArtifactId(), execution.getVersion(),
execution.getGoal(), null, null);
}
public int hashCode() {
return execution.hashCode();
}
public boolean equals(Object obj) {
if(this == obj) {
return true;
}
if(!(obj instanceof MojoExecutionMappingRequirement)) {
return false;
}
MojoExecutionMappingRequirement other = (MojoExecutionMappingRequirement) obj;
return execution.equals(other.execution);
}
public MojoExecutionKey getExecution() {
return execution;
}
}
public static class ProjectConfiguratorMappingRequirement implements ILifecycleMappingRequirement {
private final MojoExecutionKey execution; // only to make AggregateMappingLabelProvider happy. not part of the key
private final String configuratorId;
public ProjectConfiguratorMappingRequirement(MojoExecutionKey execution, String configuratorId) {
this.execution = execution;
this.configuratorId = configuratorId;
}
public int hashCode() {
return configuratorId.hashCode();
}
public boolean equals(Object obj) {
if(this == obj) {
return true;
}
if(!(obj instanceof ProjectConfiguratorMappingRequirement)) {
return false;
}
ProjectConfiguratorMappingRequirement other = (ProjectConfiguratorMappingRequirement) obj;
return configuratorId.equals(other.configuratorId);
}
public MojoExecutionKey getExecution() {
return execution;
}
public String getProjectConfiguratorId() {
return configuratorId;
}
}
private final MojoExecutionKey execution;
private final PluginExecutionMetadata mapping;
private final ILifecycleMappingRequirement requirement;
public MojoExecutionMappingConfiguration(MojoExecutionKey execution, PluginExecutionMetadata mapping) {
this.execution = execution;
this.mapping = mapping;
if(mapping == null) {
requirement = new MojoExecutionMappingRequirement(execution);
} else if(mapping.getAction() == PluginExecutionAction.configurator) {
requirement = new ProjectConfiguratorMappingRequirement(execution, LifecycleMappingFactory.getProjectConfiguratorId(mapping));
} else {
requirement = null; // this execution is fully mapped with <execute/>, <ignore/> or <error/> action
}
}
public String getArtifactId() {
return execution.getArtifactId();
}
public String getGoal() {
return execution.getGoal();
}
public boolean isMapped() {
return false;
}
public boolean isExtensionAvailable() {
return false;
}
public MojoExecutionKey getMojoExecutionKey() {
return execution;
}
public MojoExecutionKey getExecution() {
return this.execution;
}
public PluginExecutionMetadata getMapping() {
return this.mapping;
}
/**
* Mapping requirement key. Null if this mojo execution configuration is complete, i.e. mapped to ignore, execute or
* error actions.
*/
public ILifecycleMappingRequirement getLifecycleMappingRequirement() {
return requirement;
}
public int hashCode() {
int hash = execution.hashCode();
if(mapping != null) {
hash = 17 * hash + mapping.getAction().hashCode();
if(mapping.getAction() == PluginExecutionAction.configurator) {
hash += LifecycleMappingFactory.getProjectConfiguratorId(mapping).hashCode();
}
}
return hash;
}
public boolean equals(Object obj) {
if(this == obj) {
return true;
}
if(!(obj instanceof MojoExecutionMappingConfiguration)) {
return false;
}
MojoExecutionMappingConfiguration other = (MojoExecutionMappingConfiguration) obj;
if(!execution.equals(other.execution)) {
return false;
}
if(mapping == null) {
return other.mapping == null;
}
if(other.mapping == null) {
return false;
}
if(mapping.getAction() != other.mapping.getAction()) {
return false;
}
if(mapping.getAction() == PluginExecutionAction.configurator) {
String configuratorId = LifecycleMappingFactory.getProjectConfiguratorId(mapping);
String otherConfiguratorId = LifecycleMappingFactory.getProjectConfiguratorId(other.mapping);
if(!eq(configuratorId, otherConfiguratorId)) {
return false;
}
}
return true;
}
private static <T> boolean eq(T a, T b) {
return a != null ? a.equals(b) : b == null;
}
}
|
