Coverage Report

Coverage Report - org.apache.maven.tools.plugin.extractor.java.JavaMojoAnnotation

Classes in this File

 package org.apache.maven.tools.plugin.extractor.java;
 
 /*
  * 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.
  */
 
 /**
  * List of all Javadoc annotations used to describe a java Mojo.
  *
  * @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
  * @version $Id: JavaMojoAnnotation.java 1340574 2012-05-19 21:53:49Z hboutemy $
  * @since 2.4
  */
 public interface JavaMojoAnnotation
 {
     // ----------------------------------------------------------------------
     // Descriptor for type i.e. Mojo
     // ----------------------------------------------------------------------
 
     /**
      * Flags this Mojo to run it in a multi module way, i.e. aggregate the build with the set of projects listed
      * as modules.
      * <br/>
      * Refer to <code>&#64;aggregator</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String AGGREGATOR = "aggregator";
 
     /**
      * The configurator type to use when injecting parameter values into this Mojo. The value is normally deduced
      * from the Mojo's implementation language, but can be specified to allow a custom ComponentConfigurator
      * implementation to be used.
      * <br/>
      * Refer to <code>&#64;configurator &lt;roleHint&gt;</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String CONFIGURATOR = "configurator";
 
     /**
      * The description for the Mojo.
      * <br/>
      * Refer to <code>&#64;description</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      * <br/>
      * <b>Note</b>: Mojo's description is auto-detected.
      */
     String DESCRIPTION = "description";
 
     /**
      * Refer to <code>&#64;execute ...</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String EXECUTE = "execute";
 
     /**
      * The Mojo goal will be executed in isolation.
      * <br/>
      * Refer to <code>&#64;execute goal="&lt;goalName&gt;"</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String EXECUTE_GOAL = "goal";
 
     /**
      * The Mojo will be invoked in a parallel lifecycle.
      * <br/>
      * Refer to <code>&#64;execute lifecycle="&lt;lifecycleId&gt;"</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String EXECUTE_LIFECYCLE = "lifecycle";
 
     /**
      * The Mojo will be invoked in a parallel lifecycle, ending at the given phase.
      * <br/>
      * Refer to <code>&#64;execute phase="&lt;phaseName&gt;"</code>.
      * <br/>
      * Refer to <code>&#64;execute lifecycle="&lt;lifecycleId&gt;" phase="&lt;phaseName&gt;"</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String EXECUTE_PHASE = "phase";
 
     /**
      * Refer to <code>&#64;executionStrategy &lt;strategy&gt;</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String EXECUTION_STATEGY = "executionStrategy";
 
     /**
      * The name for the Mojo that users will reference to execute it.
      * <br/>
      * Refer to <code>&#64;goal &lt;goalName&gt;</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String GOAL = "goal";
 
     /**
      * The Mojo's fully-qualified class name.
      * <br/>
      * Refer to <code>&#64;implementation</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      * <br/>
      * <b>Note</b>: Mojo's implementation is auto-detected.
      */
     String IMPLEMENTATION = "implementation";
 
     /**
      * Allow Mojo inheritance.
      * <br/>
      * Refer to <code>&#64;inheritByDefault &lt;true|false&gt;</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String INHERIT_BY_DEFAULT = "inheritByDefault";
 
     /**
      * Refer to <code>&#64;instantiationStrategy &lt;per-lookup&gt;</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String INSTANTIATION_STRATEGY = "instantiationStrategy";
 
     /**
      * The implementation language for the Mojo.
      * <br/>
      * Refer to <code>&#64;language</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      * <br/>
      * <b>Note</b>: Mojo's implementation is auto-detected.
      */
     String LANGUAGE = "language";
 
     /**
      * Specifies the execution strategy.
      * <br/>
      * Refer to <code>&#64;attainAlways</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      * @deprecated use <code>&#64executionStrategy always</code> instead
      */
     String MULTI_EXECUTION_STRATEGY = "attainAlways";
 
     /**
      * Refer to <code>&#64;phase &lt;phaseName&gt;</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String PHASE = "phase";
 
     /**
      * Flags this Mojo as requiring the dependencies in the specified scope (or an implied scope) to be resolved
      * before it can execute. Currently supports <code>compile</code>, <code>runtime</code>,
      * <code>compile+runtime</code> and <code>test</code> scopes.
      * <br/>
      * Refer to <code>&#64;requiresDependencyResolution &lt;requiredScope&gt;</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String REQUIRES_DEPENDENCY_RESOLUTION = "requiresDependencyResolution";
 
     /**
      * Flags this Mojo as requiring the dependencies in the specified scope (or an implied scope) to be collected
      * before it can execute. Currently supports <code>compile</code>, <code>runtime</code>,
      * <code>compile+runtime</code> and <code>test</code> scopes.
      * <br/>
      * Refer to <code>&#64;requiresDependencyCollection &lt;requiredScope&gt;</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String REQUIRES_DEPENDENCY_COLLECTION = "requiresDependencyCollection";
 
 
     /**
      * Refer to <code>&#64;requiresDirectInvocation &lt;true|false&gt;</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String REQUIRES_DIRECT_INVOCATION = "requiresDirectInvocation";
 
     /**
      * Flags this Mojo to run online.
      * <br/>
      * Refer to <code>&#64;requiresOnline &lt;true|false&gt;</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String REQUIRES_ONLINE = "requiresOnline";
 
     /**
      * Flags this Mojo to run inside of a project.
      * <br/>
      * Refer to <code>&#64;requiresProject &lt;true|false&gt;</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String REQUIRES_PROJECT = "requiresProject";
 
     /**
      * Flags this Mojo to run inside reports.
      * <br/>
      * Refer to <code>&#64;requiresReports &lt;true|false&gt;</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String REQUIRES_REPORTS = "requiresReports";
 
     /**
      * Indicates that this mojo is thread-safe and can be run in parallel.
      *
      * <b>Note</b>: Should be defined in a Mojo Type.
      */
     String THREAD_SAFE = "threadSafe";
 
 
     // ----------------------------------------------------------------------
     // Descriptor for fields i.e. parameters
     // ----------------------------------------------------------------------
 
     /**
      * Populate the field with an instance of a Plexus component. This is like declaring a requirement in a
      * Plexus component.
      * <br/>
      * Refer to <code>&#64;component ...</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Field.
      */
     String COMPONENT = "component";
 
     /**
      * Refer to <code>&#64;component role="..."</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Field.
      */
     String COMPONENT_ROLE = "role";
 
     /**
      * Refer to <code>&#64;component roleHint="..."</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Field.
      */
     String COMPONENT_ROLEHINT = "roleHint";
 
     /**
      * Refer to <code>&#64;parameter ...</code>
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Field.
      */
     String PARAMETER = "parameter";
 
     /**
      * This defines an alias which can be used to configure a parameter. This is primarily useful to improve
      * user-friendliness.
      * <br/>
      * Refer to <code>&#64;parameter alias="..."</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Field.
      */
     String PARAMETER_ALIAS = "alias";
 
     /**
      * This defines the default value to be injected into this parameter of the Mojo at build time.
      * <br/>
      * Refer to <code>&#64;parameter default-value="..."</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Field.
      */
     String PARAMETER_DEFAULT_VALUE = "default-value";
 
     /**
      * This defines the expression used to calculate the value to be injected into this parameter of the
      * Mojo at build time.
      * <br/>
      * Refer to <code>&#64;parameter expression="..."</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Field.
      * @deprecated use PARAMETER_PROPERTY instead
      */
     String PARAMETER_EXPRESSION = "expression";
 
     /**
      * This defines the property used to calculate the value to be injected into this parameter of the
      * Mojo at build time, which can come from <code>-D</code> execution, setting properties or pom properties.
      * <br/>
      * Refer to <code>&#64;parameter property="..."</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Field.
      */
     String PARAMETER_PROPERTY = "property";
 
     /**
      * This defines the default implementation in the case the parameter type is an interface.
      * <br/>
      * Refer to <code>&#64;parameter implementation="..."</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Field.
      */
     String PARAMETER_IMPLEMENTATION = "implementation";
 
     /**
      * Specifies that this parameter cannot be configured directly by the user (as in the case of POM-specified
      * configuration).
      * <br/>
      * Refer to <code>&#64;readonly</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Field.
      */
     String READONLY = "readonly";
 
     /**
      * Specifies that this parameter is required for the Mojo to function.
      * <br/>
      * Refer to <code>&#64;required</code>.
      * <br/>
      * <b>Note</b>: Should be defined in a Mojo Field.
      */
     String REQUIRED = "required";
 
     // ----------------------------------------------------------------------
     // Descriptor for type and fields
     // ----------------------------------------------------------------------
 
     /**
      * Refer to <code>&#64;since &lt;deprecated-text&gt;</code>
      * <br/>
      * <b>Note</b>: Could be defined in a Mojo Type or a Mojo Field.
      */
     String SINCE = "since";
 
     /**
      * Refer to <code>&#64;deprecated &lt;since-text&gt;</code>
      * <br/>
      * <b>Note</b>: Could be defined in a Mojo Type or a Mojo Field.
      */
     String DEPRECATED = "deprecated";
 
 }

1		package org.apache.maven.tools.plugin.extractor.java;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one
5		* or more contributor license agreements. See the NOTICE file
6		* distributed with this work for additional information
7		* regarding copyright ownership. The ASF licenses this file
8		* to you under the Apache License, Version 2.0 (the
9		* "License"); you may not use this file except in compliance
10		* with the License. You may obtain a copy of the License at
11		*
12		* http://www.apache.org/licenses/LICENSE-2.0
13		*
14		* Unless required by applicable law or agreed to in writing,
15		* software distributed under the License is distributed on an
16		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17		* KIND, either express or implied. See the License for the
18		* specific language governing permissions and limitations
19		* under the License.
20		*/
21
22		/**
23		* List of all Javadoc annotations used to describe a java Mojo.
24		*
25		* @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
26		* @version $Id: JavaMojoAnnotation.java 1340574 2012-05-19 21:53:49Z hboutemy $
27		* @since 2.4
28		*/
29		public interface JavaMojoAnnotation
30		{
31		// ----------------------------------------------------------------------
32		// Descriptor for type i.e. Mojo
33		// ----------------------------------------------------------------------
34
35		/**
36		* Flags this Mojo to run it in a multi module way, i.e. aggregate the build with the set of projects listed
37		* as modules.
38		* <br/>
39		* Refer to <code>@aggregator</code>.
40		* <br/>
41		* <b>Note</b>: Should be defined in a Mojo Type.
42		*/
43		String AGGREGATOR = "aggregator";
44
45		/**
46		* The configurator type to use when injecting parameter values into this Mojo. The value is normally deduced
47		* from the Mojo's implementation language, but can be specified to allow a custom ComponentConfigurator
48		* implementation to be used.
49		* <br/>
50		* Refer to <code>@configurator <roleHint></code>.
51		* <br/>
52		* <b>Note</b>: Should be defined in a Mojo Type.
53		*/
54		String CONFIGURATOR = "configurator";
55
56		/**
57		* The description for the Mojo.
58		* <br/>
59		* Refer to <code>@description</code>.
60		* <br/>
61		* <b>Note</b>: Should be defined in a Mojo Type.
62		* <br/>
63		* <b>Note</b>: Mojo's description is auto-detected.
64		*/
65		String DESCRIPTION = "description";
66
67		/**
68		* Refer to <code>@execute ...</code>.
69		* <br/>
70		* <b>Note</b>: Should be defined in a Mojo Type.
71		*/
72		String EXECUTE = "execute";
73
74		/**
75		* The Mojo goal will be executed in isolation.
76		* <br/>
77		* Refer to <code>@execute goal="<goalName>"</code>.
78		* <br/>
79		* <b>Note</b>: Should be defined in a Mojo Type.
80		*/
81		String EXECUTE_GOAL = "goal";
82
83		/**
84		* The Mojo will be invoked in a parallel lifecycle.
85		* <br/>
86		* Refer to <code>@execute lifecycle="<lifecycleId>"</code>.
87		* <br/>
88		* <b>Note</b>: Should be defined in a Mojo Type.
89		*/
90		String EXECUTE_LIFECYCLE = "lifecycle";
91
92		/**
93		* The Mojo will be invoked in a parallel lifecycle, ending at the given phase.
94		* <br/>
95		* Refer to <code>@execute phase="<phaseName>"</code>.
96		* <br/>
97		* Refer to <code>@execute lifecycle="<lifecycleId>" phase="<phaseName>"</code>.
98		* <br/>
99		* <b>Note</b>: Should be defined in a Mojo Type.
100		*/
101		String EXECUTE_PHASE = "phase";
102
103		/**
104		* Refer to <code>@executionStrategy <strategy></code>.
105		* <br/>
106		* <b>Note</b>: Should be defined in a Mojo Type.
107		*/
108		String EXECUTION_STATEGY = "executionStrategy";
109
110		/**
111		* The name for the Mojo that users will reference to execute it.
112		* <br/>
113		* Refer to <code>@goal <goalName></code>.
114		* <br/>
115		* <b>Note</b>: Should be defined in a Mojo Type.
116		*/
117		String GOAL = "goal";
118
119		/**
120		* The Mojo's fully-qualified class name.
121		* <br/>
122		* Refer to <code>@implementation</code>.
123		* <br/>
124		* <b>Note</b>: Should be defined in a Mojo Type.
125		* <br/>
126		* <b>Note</b>: Mojo's implementation is auto-detected.
127		*/
128		String IMPLEMENTATION = "implementation";
129
130		/**
131		* Allow Mojo inheritance.
132		* <br/>
133		* Refer to <code>@inheritByDefault <true\|false></code>.
134		* <br/>
135		* <b>Note</b>: Should be defined in a Mojo Type.
136		*/
137		String INHERIT_BY_DEFAULT = "inheritByDefault";
138
139		/**
140		* Refer to <code>@instantiationStrategy <per-lookup></code>.
141		* <br/>
142		* <b>Note</b>: Should be defined in a Mojo Type.
143		*/
144		String INSTANTIATION_STRATEGY = "instantiationStrategy";
145
146		/**
147		* The implementation language for the Mojo.
148		* <br/>
149		* Refer to <code>@language</code>.
150		* <br/>
151		* <b>Note</b>: Should be defined in a Mojo Type.
152		* <br/>
153		* <b>Note</b>: Mojo's implementation is auto-detected.
154		*/
155		String LANGUAGE = "language";
156
157		/**
158		* Specifies the execution strategy.
159		* <br/>
160		* Refer to <code>@attainAlways</code>.
161		* <br/>
162		* <b>Note</b>: Should be defined in a Mojo Type.
163		* @deprecated use <code>&#64executionStrategy always</code> instead
164		*/
165		String MULTI_EXECUTION_STRATEGY = "attainAlways";
166
167		/**
168		* Refer to <code>@phase <phaseName></code>.
169		* <br/>
170		* <b>Note</b>: Should be defined in a Mojo Type.
171		*/
172		String PHASE = "phase";
173
174		/**
175		* Flags this Mojo as requiring the dependencies in the specified scope (or an implied scope) to be resolved
176		* before it can execute. Currently supports <code>compile</code>, <code>runtime</code>,
177		* <code>compile+runtime</code> and <code>test</code> scopes.
178		* <br/>
179		* Refer to <code>@requiresDependencyResolution <requiredScope></code>.
180		* <br/>
181		* <b>Note</b>: Should be defined in a Mojo Type.
182		*/
183		String REQUIRES_DEPENDENCY_RESOLUTION = "requiresDependencyResolution";
184
185		/**
186		* Flags this Mojo as requiring the dependencies in the specified scope (or an implied scope) to be collected
187		* before it can execute. Currently supports <code>compile</code>, <code>runtime</code>,
188		* <code>compile+runtime</code> and <code>test</code> scopes.
189		* <br/>
190		* Refer to <code>@requiresDependencyCollection <requiredScope></code>.
191		* <br/>
192		* <b>Note</b>: Should be defined in a Mojo Type.
193		*/
194		String REQUIRES_DEPENDENCY_COLLECTION = "requiresDependencyCollection";
195
196
197		/**
198		* Refer to <code>@requiresDirectInvocation <true\|false></code>.
199		* <br/>
200		* <b>Note</b>: Should be defined in a Mojo Type.
201		*/
202		String REQUIRES_DIRECT_INVOCATION = "requiresDirectInvocation";
203
204		/**
205		* Flags this Mojo to run online.
206		* <br/>
207		* Refer to <code>@requiresOnline <true\|false></code>.
208		* <br/>
209		* <b>Note</b>: Should be defined in a Mojo Type.
210		*/
211		String REQUIRES_ONLINE = "requiresOnline";
212
213		/**
214		* Flags this Mojo to run inside of a project.
215		* <br/>
216		* Refer to <code>@requiresProject <true\|false></code>.
217		* <br/>
218		* <b>Note</b>: Should be defined in a Mojo Type.
219		*/
220		String REQUIRES_PROJECT = "requiresProject";
221
222		/**
223		* Flags this Mojo to run inside reports.
224		* <br/>
225		* Refer to <code>@requiresReports <true\|false></code>.
226		* <br/>
227		* <b>Note</b>: Should be defined in a Mojo Type.
228		*/
229		String REQUIRES_REPORTS = "requiresReports";
230
231		/**
232		* Indicates that this mojo is thread-safe and can be run in parallel.
233		*
234		* <b>Note</b>: Should be defined in a Mojo Type.
235		*/
236		String THREAD_SAFE = "threadSafe";
237
238
239		// ----------------------------------------------------------------------
240		// Descriptor for fields i.e. parameters
241		// ----------------------------------------------------------------------
242
243		/**
244		* Populate the field with an instance of a Plexus component. This is like declaring a requirement in a
245		* Plexus component.
246		* <br/>
247		* Refer to <code>@component ...</code>.
248		* <br/>
249		* <b>Note</b>: Should be defined in a Mojo Field.
250		*/
251		String COMPONENT = "component";
252
253		/**
254		* Refer to <code>@component role="..."</code>.
255		* <br/>
256		* <b>Note</b>: Should be defined in a Mojo Field.
257		*/
258		String COMPONENT_ROLE = "role";
259
260		/**
261		* Refer to <code>@component roleHint="..."</code>.
262		* <br/>
263		* <b>Note</b>: Should be defined in a Mojo Field.
264		*/
265		String COMPONENT_ROLEHINT = "roleHint";
266
267		/**
268		* Refer to <code>@parameter ...</code>
269		* <br/>
270		* <b>Note</b>: Should be defined in a Mojo Field.
271		*/
272		String PARAMETER = "parameter";
273
274		/**
275		* This defines an alias which can be used to configure a parameter. This is primarily useful to improve
276		* user-friendliness.
277		* <br/>
278		* Refer to <code>@parameter alias="..."</code>.
279		* <br/>
280		* <b>Note</b>: Should be defined in a Mojo Field.
281		*/
282		String PARAMETER_ALIAS = "alias";
283
284		/**
285		* This defines the default value to be injected into this parameter of the Mojo at build time.
286		* <br/>
287		* Refer to <code>@parameter default-value="..."</code>.
288		* <br/>
289		* <b>Note</b>: Should be defined in a Mojo Field.
290		*/
291		String PARAMETER_DEFAULT_VALUE = "default-value";
292
293		/**
294		* This defines the expression used to calculate the value to be injected into this parameter of the
295		* Mojo at build time.
296		* <br/>
297		* Refer to <code>@parameter expression="..."</code>.
298		* <br/>
299		* <b>Note</b>: Should be defined in a Mojo Field.
300		* @deprecated use PARAMETER_PROPERTY instead
301		*/
302		String PARAMETER_EXPRESSION = "expression";
303
304		/**
305		* This defines the property used to calculate the value to be injected into this parameter of the
306		* Mojo at build time, which can come from <code>-D</code> execution, setting properties or pom properties.
307		* <br/>
308		* Refer to <code>@parameter property="..."</code>.
309		* <br/>
310		* <b>Note</b>: Should be defined in a Mojo Field.
311		*/
312		String PARAMETER_PROPERTY = "property";
313
314		/**
315		* This defines the default implementation in the case the parameter type is an interface.
316		* <br/>
317		* Refer to <code>@parameter implementation="..."</code>.
318		* <br/>
319		* <b>Note</b>: Should be defined in a Mojo Field.
320		*/
321		String PARAMETER_IMPLEMENTATION = "implementation";
322
323		/**
324		* Specifies that this parameter cannot be configured directly by the user (as in the case of POM-specified
325		* configuration).
326		* <br/>
327		* Refer to <code>@readonly</code>.
328		* <br/>
329		* <b>Note</b>: Should be defined in a Mojo Field.
330		*/
331		String READONLY = "readonly";
332
333		/**
334		* Specifies that this parameter is required for the Mojo to function.
335		* <br/>
336		* Refer to <code>@required</code>.
337		* <br/>
338		* <b>Note</b>: Should be defined in a Mojo Field.
339		*/
340		String REQUIRED = "required";
341
342		// ----------------------------------------------------------------------
343		// Descriptor for type and fields
344		// ----------------------------------------------------------------------
345
346		/**
347		* Refer to <code>@since <deprecated-text></code>
348		* <br/>
349		* <b>Note</b>: Could be defined in a Mojo Type or a Mojo Field.
350		*/
351		String SINCE = "since";
352
353		/**
354		* Refer to <code>@deprecated <since-text></code>
355		* <br/>
356		* <b>Note</b>: Could be defined in a Mojo Type or a Mojo Field.
357		*/
358		String DEPRECATED = "deprecated";
359
360		}