<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">

<html>
<head>
    <meta name="copyright" content="Copyright (c) 2009 Shane Clarke. 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: Shane Clarke - initial API and implementation">
	<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
	<meta http-equiv="Content-Style-Type" content="text/css">
	<title>Annotation Processors</title>
	<link href="../book.css" rel="stylesheet" charset="ISO-8859-1" type="text/css">
</head>

<body>
<h2>Annotation Validation</h2>
<p>JAX-WS Tools provides JDT-APT Annotation Processors that gather information about the source code as it is being edited.</p>
<p>The processors report errors and warnings in the Problems View when JAX-WS rules are broken.</p> 
<p>JAX-WS Annotation processing is disabled by default.</p>
<p><img src="../images/ngrelt.png" alt="Related tasks" border="0" ></p>
<a href="PLUGINS_ROOT/org.eclipse.jst.ws.cxf.doc.user/tasks/configuring_jaxws_annotation_processing.html">Enable JAX-WS Annotation Processing</a><br>    
</body>
</html>