polygene-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nic...@apache.org
Subject [20/50] [abbrv] zest-qi4j git commit: Fixed all JavaDoc ERRORS reported by DocLint in Java 8.
Date Fri, 24 Apr 2015 06:36:33 GMT
http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial10/HelloWorldComposite.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial10/HelloWorldComposite.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial10/HelloWorldComposite.java
index f421c21..35c3fd9 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial10/HelloWorldComposite.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial10/HelloWorldComposite.java
@@ -6,12 +6,12 @@ import org.qi4j.api.mixin.Mixins;
 // START SNIPPET: solution
 
 /**
- * This Composite interface declares transitively
- * all the Fragments of the HelloWorld composite.
- * <p/>
+ * This Composite interface declares transitively all the Fragments of the HelloWorld composite.
+ * <p>
  * The Fragments are all abstract, so it's ok to
  * put the domain methods here. Otherwise the Fragments
  * would have to implement all methods, including those in Composite.
+ * </p>
  */
 @Mixins( { HelloWorldMixin.class } )
 public interface HelloWorldComposite

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial2/package.html
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial2/package.html
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial2/package.html
index fd147b4..1487ad7 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial2/package.html
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial2/package.html
@@ -1,6 +1,6 @@
 <body>
 <h1>Tutorial 2 - Creating a Composite</h1>
-
+<p>
 In this tutorial we will create a TransientComposite interface that ties all pieces together.
 The TransientComposite interface is a regular Java interface which extends the interfaces
you
 want to expose from your domain model, and which uses various annotations to declare
@@ -8,11 +8,14 @@ what Fragments to include. Fragments include Mixins, Concerns, SideEffects
and C
 In this tutorial we will only use Mixins. When a TransientComposite is instantiated at runtime
 the framework will inspect the interface to determine what the TransientComposite instance
should
 look like in terms of used Fragments.
-<p/>
+</p>
+<p>
 In Qi4j all method parameters are considered mandatory unless marked as @Optional. Therefore
you can
 remove the null checks in the Mixin. If a null value is passed in an exception will be thrown
by Qi4j.
-<p/>
+</p>
+<p>
 Steps for this tutorial:
+</p>
 <ol>
     <li>Create an interface that extends the domain interface HelloWorld and
         org.qi4j.api.composite.TransientComposite.

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial3/HelloWorldComposite.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial3/HelloWorldComposite.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial3/HelloWorldComposite.java
index bde392b..af32039 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial3/HelloWorldComposite.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial3/HelloWorldComposite.java
@@ -6,10 +6,10 @@ import org.qi4j.api.mixin.Mixins;
 // START SNIPPET: solution
 
 /**
- * This Composite interface declares all the Fragments
- * of the HelloWorld composite.
- * <p/>
+ * This Composite interface declares all the Fragments of the HelloWorld composite.
+ * <p>
  * Currently it only declares one Mixin.
+ * </p>
  */
 @Mixins( HelloWorldMixin.class )
 public interface HelloWorldComposite

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial3/package.html
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial3/package.html
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial3/package.html
index b463d66..a0d2273 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial3/package.html
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial3/package.html
@@ -1,13 +1,15 @@
 <body>
 <h1>Tutorial 3 - Mixins</h1>
-
+<p>
 In this tutorial we refactor the Mixin from the previous steps into two, one which serves
 the behaviour interface and one which serves the state interface. This makes it possible
to
 reuse the interfaces independently and also makes it easier to exchange one interface implementation
 with another. This also allows us to specify the new Mixins as default implementations of
 the interfaces by adding @Mixins annotations on them.
-<p/>
+</p>
+<p>
 Steps for this tutorial:
+</p>
 <ol>
     <li>Refactor the Mixin into one which implement the behaviour interface and one
which implements the state
         interface. Use the @This injection annotation to allow the behaviour to access the
state.

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/HelloWorldBehaviour.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/HelloWorldBehaviour.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/HelloWorldBehaviour.java
index 49174d0..1a096ae 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/HelloWorldBehaviour.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/HelloWorldBehaviour.java
@@ -5,10 +5,10 @@ import org.qi4j.api.mixin.Mixins;
 // START SNIPPET: solution
 
 /**
- * This interface contains only the behaviour
- * of the HelloWorld object.
- * <p/>
+ * This interface contains only the behaviour of the HelloWorld object.
+ * <p>
  * It declares what Mixin to use as default implementation.
+ * </p>
  */
 @Mixins( HelloWorldBehaviourMixin.class )
 public interface HelloWorldBehaviour

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/HelloWorldBehaviourMixin.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/HelloWorldBehaviourMixin.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/HelloWorldBehaviourMixin.java
index 31bb921..3a73e94 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/HelloWorldBehaviourMixin.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/HelloWorldBehaviourMixin.java
@@ -5,14 +5,14 @@ import org.qi4j.api.injection.scope.This;
 // START SNIPPET: solution
 
 /**
- * This is the implementation of the HelloWorld
- * behaviour interface.
- * <p/>
+ * This is the implementation of the HelloWorld behaviour interface.
+ * <p>
  * It uses a @This Dependency Injection
  * annotation to access the state of the Composite. The field
  * will be automatically injected when the Composite
  * is instantiated. Injections of resources or references
  * can be provided either to fields, constructor parameters or method parameters.
+ * </p>
  */
 public class HelloWorldBehaviourMixin
     implements HelloWorldBehaviour

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/HelloWorldComposite.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/HelloWorldComposite.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/HelloWorldComposite.java
index 0f11316..e104a96 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/HelloWorldComposite.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/HelloWorldComposite.java
@@ -7,11 +7,12 @@ import org.qi4j.api.composite.TransientComposite;
 /**
  * This Composite interface declares all the Fragments
  * of the HelloWorld composite.
- * <p/>
+ * <p>
  * The Mixins annotation has been moved to the respective sub-interfaces.
  * The sub-interfaces therefore declare themselves what mixin implementation
  * is preferred. This interface could still have its own Mixins annotation
  * with overrides of those defaults however.
+ * </p>
  */
 public interface HelloWorldComposite
     extends HelloWorld, TransientComposite

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/package.html
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/package.html
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/package.html
index 203287b..dd69d87 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/package.html
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial4/package.html
@@ -1,18 +1,20 @@
 <body>
 <h1>Tutorial 4 - Concerns</h1>
-
+<p>
 In this tutorial we refactor the mixin from the previous steps so that the result of the
say() method
 is modified to be prefixed with "Simon says:". To do this we need to implement a Concern
for
 the say() method. Concerns are a type of Modifier which modify the behaviour of
 the methods in Mixins. They do this by intercepting the invocation of the TransientComposite.
This allows
 them to change the invocation parameters, return their own values or throw their own exceptions,
 and do other things which directly affect the invocation of the method.
-<p/>
+</p>
+<p>
 Concerns should not perform any side-effects, such as updating state in another TransientComposite,
Mixin
 or similar. Any side-effects are done in SideEffects, which is another type of Modifier,
which are
 allowed to perform side-effects but, in contrast to Concerns, cannot change the parameters
or
 in any other way change the result of the invocation.
-<p/>
+</p>
+<p>
 Concerns are implemented in one of two ways: either create a class which directly implements
 the interface whose methods should be modified, or create a generic Modifier by implementing
 the InvocationHandler interface (or subclass GenericConcern which does this for you).
@@ -21,11 +23,14 @@ which has the same type as the interface the Concern implements. When
the Transi
 the Concern will be called, allowing it to perform it's work. If the call should proceed,
then
 invoke the method again on the injected object. The preferred way to do all of this is to
subclass
 ConcernOf which does all of this for you.
-<p/>
+</p>
+<p>
 Concerns are applied by adding an @Concerns annotation on the TransientComposite, the domain
interface,
 or the Mixin implementation. Any of these works, and where to put it is a matter of design
choice.
-<p/>
+</p>
+<p>
 Steps for this tutorial:
+</p>
 <ol>
     <li>Create a typed concern, implement the HelloWorldBehaviour and let it modify
the result
         of the base method by prefix the result with "Simon says:".

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldBehaviour.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldBehaviour.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldBehaviour.java
index 2435747..0392284 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldBehaviour.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldBehaviour.java
@@ -5,8 +5,9 @@ import org.qi4j.api.mixin.Mixins;
 /**
  * This interface contains only the behaviour
  * of the HelloWorld object.
- * <p/>
+ * <p>
  * It declares what Mixin to use as default implementation.
+ * </p>
  */
 @Mixins( HelloWorldBehaviourMixin.class )
 public interface HelloWorldBehaviour

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldBehaviourMixin.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldBehaviourMixin.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldBehaviourMixin.java
index a1841cc..e632894 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldBehaviourMixin.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldBehaviourMixin.java
@@ -8,12 +8,13 @@ import org.qi4j.api.injection.scope.This;
 /**
  * This is the implementation of the HelloWorld
  * behaviour interface.
- * <p/>
+ * <p>
  * It uses a @This Dependency Injection
  * annotation to access the state of the Composite. The field
  * will be automatically injected when the Composite
  * is instantiated. Injections of resources or references
  * can be provided either to fields, constructor parameters or method parameters.
+ * </p>
  */
 @Concerns( HelloWorldBehaviourConcern.class )
 public class HelloWorldBehaviourMixin

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldComposite.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldComposite.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldComposite.java
index 197de50..5d52df1 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldComposite.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldComposite.java
@@ -5,11 +5,12 @@ import org.qi4j.api.composite.TransientComposite;
 /**
  * This Composite interface declares transitively
  * all the Fragments of the HelloWorld composite.
- * <p/>
+ * <p>
  * What Mixins to use and what Assertions should
  * apply to the methods can be found by exploring
  * the interfaces extended by this Composite interface,
  * and by looking at the declared Mixins.
+ * </p>
  */
 public interface HelloWorldComposite
     extends HelloWorld, TransientComposite

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldState.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldState.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldState.java
index c31c41d..8871fab 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldState.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/HelloWorldState.java
@@ -5,8 +5,9 @@ import org.qi4j.api.mixin.Mixins;
 /**
  * This interface contains only the state
  * of the HelloWorld object.
- * <p/>
+ * <p>
  * It declares what Mixin to use as default implementation.
+ * </p>
  */
 @Mixins( HelloWorldStateMixin.class )
 public interface HelloWorldState

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/package.html
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/package.html
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/package.html
index 566059c..11ecec6 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/package.html
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial5/package.html
@@ -1,38 +1,44 @@
 <body>
 <h1>Tutorial 5 - Constraints</h1>
-
+<p>
 In this tutorial we will look at how to use Constraints. When we pass parameters to
 methods in regular Java code the only restriction we can make is to denote a type.
 Any other constraints on the input value, such as whether the parameter is optional, integer
ranges,
 string regular expressions, and so on, cannot be expressed, and so we have to put this into
Javadoc, and
 then manually add these checks in the implementation class.
-<p/>
+</p>
+<p>
 In Qi4j there is the option to use Constraints, which are further restrictions on the parameters.
 This is implemented by having an annotation that describes what the Constraint does, and
then
 an implementation class that checks whether a specific value fulfills the Constraint or not.
-<p/>
+</p>
+<p>
 There are a number of pre-written constraints in Qi4j which you can use. The null check of
the original
 HelloWorld version is already handled by default since Qi4j considers method parameters to
be mandatory if not
 explicitly marked with the @Optional annotation. So, instead of doing that check we will
add
 other checks that are useful to make, such as ensuring that the passed in string is not empty.
-<p/>
+</p>
+<p>
 The only thing you have to do is add the annotation @NotEmpty to the method parameters you
want to
 constrain in this way. The annotation has a default implementation declared in it by using
the @Constraints
 annotation. You can either just use this, which is the common case, or override it by declaring
your
 own @Constraints annotation in the TransientComposite type.
-<p/>
+</p>
+<p>
 You can add as many Constraint annotations you want to a parameter. All of them will be checked
whenever a method is
 called.
-<p/>
+</p>
+<p>
 Steps for this tutorial:
+</p>
 <ol>
     <li>Add @NotEmpty to the state parameters.</li>
 </ol>
-<p><em>Note:</em><br/>
+<p><em>Note:</em></p>
+<p>
     The previous steps had a dependency to the <code>qi4j-core-api</code> only.
The constraints
     you've used in this step, introduce a new dependency to the <code>qi4j-lib-constraints</code>
     library, where all the constraint related classes reside. So update your classpath settings
     accordingly.
 </p>
 </body>
-        
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldBehaviour.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldBehaviour.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldBehaviour.java
index 7312c45..ba34e73 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldBehaviour.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldBehaviour.java
@@ -8,9 +8,10 @@ import org.qi4j.api.mixin.Mixins;
 /**
  * This interface contains only the behaviour
  * of the HelloWorld object.
- * <p/>
+ * <p>
  * It declares what Mixin to use as default implementation, and also the extra
  * concern to be applied.
+ * </p>
  */
 @Concerns( HelloWorldBehaviourConcern.class )
 @Mixins( HelloWorldBehaviourMixin.class )

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldBehaviourMixin.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldBehaviourMixin.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldBehaviourMixin.java
index 1d59c6e..73ad983 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldBehaviourMixin.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldBehaviourMixin.java
@@ -7,12 +7,13 @@ import org.qi4j.api.injection.scope.This;
 /**
  * This is the implementation of the HelloWorld
  * behaviour interface.
- * <p/>
+ * <p>
  * It uses a @This DependencyModel Injection
  * annotation to access the state of the Composite. The field
  * will be automatically injected when the Composite
  * is instantiated. Injections of resources or references
  * can be provided either to fields, constructor parameters or method parameters.
+ * </p>
  */
 public class HelloWorldBehaviourMixin
     implements HelloWorldBehaviour

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldComposite.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldComposite.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldComposite.java
index 87c3c74..18c772d 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldComposite.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldComposite.java
@@ -5,11 +5,12 @@ import org.qi4j.api.composite.TransientComposite;
 /**
  * This Composite interface declares transitively
  * all the Fragments of the HelloWorld composite.
- * <p/>
+ * <p>
  * What Mixins to use and what Concerns should
  * apply to the methods can be found by exploring
  * the interfaces extended by this Composite interface,
  * and by looking at the declared @Mixins annotations.
+ * </p>
  */
 public interface HelloWorldComposite
     extends HelloWorld, TransientComposite

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldState.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldState.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldState.java
index 6cb6467..0f80254a 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldState.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/HelloWorldState.java
@@ -8,9 +8,10 @@ import org.qi4j.library.constraints.annotation.NotEmpty;
 /**
  * This interface contains only the state
  * of the HelloWorld object.
- * <p/>
+ * <p>
  * The parameters are declared as @NotEmpty, so the client cannot pass in empty strings
  * as values.
+ * </p>
  */
 @Mixins( HelloWorldStateMixin.class )
 public interface HelloWorldState

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/package.html
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/package.html
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/package.html
index 1a381d9..20e0a01 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/package.html
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial6/package.html
@@ -1,18 +1,20 @@
 <body>
 <h1>Tutorial 6 - SideEffects</h1>
-
+<p>
 The current say() method has a Concern that modifies its value. What if we instead want
 the value to be intact, but log that value to System.out? That would be considered a side-effect
 of the say() method, and should hence not be done in a Concern. It would be better to implement
 this in a SideEffect. SideEffects are executed after the Mixin and all Concerns for a method
are done,
 which means that the final result has been computed. A SideEffect can access this result
value, and
 then use that for further computation, but it should not change the value or throw an exception.
-<p/>
+</p>
+<p>
 SideEffects can be either typed or generic, just like Concerns. In the typed case we are
 interested in specifying SideEffects for one or more particular methods, whereas in the generic
 case the SideEffect is not really relying on what method is being invoked. Both are useful
 in different scenarios.
-<p/>
+</p>
+<p>
 The easiest way to implement a typed SideEffect is to subclass the SideEffectOf class. This
gives
 you access to the result of the real method invocation by using the "result" field, which
has the same
 type as the interface of the method you want the code to be a side-effect of. Note that calling
"result"
@@ -20,11 +22,14 @@ does not actually do anything, it only returns the value (or throws the
exceptio
 from the original method) that has already been computed. Similarly, since the method is
already done,
 you can return anything from the SideEffect method. The framework will simply throw it away,
and also
 ignore any exceptions that you throw in your code.
-<p/>
+</p>
+<p>
 To declare that the SideEffect should be used you add the @SideEffects annotation to either
the
 TransientComposite type, the Mixin type, or the Mixin implementation. Either works.
-<p/>
+</p>
+<p>
 Steps for this tutorial:
+</p>
 <ol>
     <li>Create the SideEffect class that logs the result of say() to System.out.</li>
     <li>Add a @SideEffects annotation with the SideEffect to the HelloWorldComposite
interface.</li>

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/HelloWorldBehaviourMixin.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/HelloWorldBehaviourMixin.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/HelloWorldBehaviourMixin.java
index bbbc50e..726b3f6 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/HelloWorldBehaviourMixin.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/HelloWorldBehaviourMixin.java
@@ -5,12 +5,13 @@ import org.qi4j.api.injection.scope.This;
 /**
  * This is the implementation of the HelloWorld
  * behaviour interface.
- * <p/>
+ * <p>
  * It uses a @This DependencyModel Injection
  * annotation to access the state of the Composite. The field
  * will be automatically injected when the Composite
  * is instantiated. Injections of resources or references
  * can be provided either to fields, constructor parameters or method parameters.
+ * </p>
  */
 public class HelloWorldBehaviourMixin
     implements HelloWorldBehaviour

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/HelloWorldComposite.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/HelloWorldComposite.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/HelloWorldComposite.java
index 23b00bd..c73efdb 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/HelloWorldComposite.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/HelloWorldComposite.java
@@ -9,8 +9,9 @@ import org.qi4j.api.sideeffect.SideEffects;
 /**
  * This Composite interface declares transitively
  * all the Fragments of the HelloWorld composite.
- * <p/>
+ * <p>
  * It declares that the HelloWorldBehaviourSideEffect should be applied.
+ * </p>
  */
 @Mixins( { HelloWorldBehaviourMixin.class, HelloWorldStateMixin.class } )
 @SideEffects( HelloWorldBehaviourSideEffect.class )

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/HelloWorldState.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/HelloWorldState.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/HelloWorldState.java
index 8b81c07..a3143fb 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/HelloWorldState.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/HelloWorldState.java
@@ -7,9 +7,10 @@ import org.qi4j.library.constraints.annotation.NotEmpty;
 /**
  * This interface contains only the state
  * of the HelloWorld object.
- * <p/>
+ * <p>
  * The parameters are declared as @NotEmpty, so the client cannot pass in empty strings
  * as values.
+ * </p>
  */
 public interface HelloWorldState
 {

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/package.html
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/package.html
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/package.html
index b9ca91e..57609da 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/package.html
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial7/package.html
@@ -1,37 +1,47 @@
 <body>
 <h1>Tutorial 7 - Properties</h1>
-
+<p>
 One of the goals of Qi4j is to give you domain modeling tools that allow you to more concisely
use
 domain concepts in code. One of the things we do rather often is model Properties of objects
as getters
 and setters. But this is a very weak model, and does not give you any access to metadata
about the property,
 and also makes common tasks like UI binding non-trivial. There is also a lot of repetition
of code, which
 is unnecessary. Using JavaBeans conventions one typically have to have code in five places
for one property,
 whereas in Qi4j the same thing can be achieved with one line of code.
-<p/>
+</p>
+<p>
 But lets start out easy. To declare a property you have to make a method in a mixin type
that returns a value
 of the type Property, and which does not take any parameters. Here's a simple example:
+</p>
 <pre>
     Property&lt;String&gt; name();
 </pre>
+<p>
 This declares a Property of type String with the name "name". The Property interface has
methods "get" and "set"
 to access and mutate the value, respectively.
-<p/>
+</p>
+<p>
 For now you will be responsible for implementing these methods, but later on these will be
handled automatically,
 thus reducing Properties to one-liners!
-<p/>
+</p>
+<p>
 In the Mixin implementation of the interface with the Property declaration you should have
an injection
 of the Property, which is created for you by Qi4j. The injection can be done in a field like
this:
+</p>
 <pre>
     &#64;State Property&lt;String&gt; name;
 </pre>
+<p>
 The State dependency injection annotation means that Qi4j will inject the Property for you.
The field
 has the name "name", which matches the name in the interface, and therefore that Property
is injected. You can
 then implement the method trivially by just returning the "name" field.
-<p/>
+</p>
+<p>
 Properties can have Constraints just like method parameters. Simply set them on the Property
method instead,
 and they will be applied just as before when you call "set".
-<p/>
+</p>
+<p>
 Steps for this tutorial:
+</p>
 <ol>
     <li>Remove JavaBeans properties from HelloWorldState.</li>
     <li>Remove HelloWorld and add the HelloWorldState and HelloWorldBehavior to the
HelloWorldComposite interface.</li>

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial8/HelloWorldBehaviourMixin.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial8/HelloWorldBehaviourMixin.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial8/HelloWorldBehaviourMixin.java
index 936fdf4..226dc0a 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial8/HelloWorldBehaviourMixin.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial8/HelloWorldBehaviourMixin.java
@@ -7,8 +7,9 @@ import org.qi4j.api.injection.scope.This;
 /**
  * This is the implementation of the HelloWorld
  * behaviour interface.
- * <p/>
+ * <p>
  * This version access the state using Qi4j Properties.
+ * </p>
  */
 public class HelloWorldBehaviourMixin
     implements HelloWorldBehaviour

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial8/HelloWorldState.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial8/HelloWorldState.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial8/HelloWorldState.java
index d5ec464..c85d600 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial8/HelloWorldState.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial8/HelloWorldState.java
@@ -8,9 +8,10 @@ import org.qi4j.library.constraints.annotation.NotEmpty;
 /**
  * This interface contains only the state
  * of the HelloWorld object.
- * <p/>
+ * <p>
  * The state is now declared using Properties. The @NotEmpty annotation is applied to the
  * method instead, and has the same meaning as before.
+ * </p>
  */
 public interface HelloWorldState
 {

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial8/package.html
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial8/package.html
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial8/package.html
index db07cdd..00a0c5a 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial8/package.html
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial8/package.html
@@ -1,6 +1,6 @@
 <body>
 <h1>Tutorial 8 - Generic mixins</h1>
-
+<p>
 In this tutorial we will look at how to use generic Fragments. So far all Fragments, i.e.
 the Concerns, SideEffects, and Mixins, have directly implemented the domain interface. But
sometimes it is
 useful to be able to provide a generic implementation of an interface. An example of this
is
@@ -8,19 +8,24 @@ the HelloWorldState interface. Since it only handles properties, and the
old ver
 for naming getters and setters we could create a mixin that handles invocations of such methods
 automatically for us by storing the properties in a map and use the methods
 to look them up.
-<p/>
+</p>
+<p>
 Implementing a generic Fragment is done by creating a class that implements the interface
 java.lang.proxy.InvocationHandler. This has a single "invoke" method which is passed the
 object that was invoked (the TransientComposite in this case), the method, and the arguments.
The
 Fragment is then allowed to implement the method any way it wants.
-<p/>
+</p>
+<p>
 Since interfaces with only Properties is such a common case Qi4j already has a generic Mixin
 that implements the Properties management described above, but for the builtin Property type
instead
 of the getter/setter variant. The class is aptly named PropertyMixin.
-<p/>
+</p>
+<p>
 While we could use it, for now we will implement it ourselves to get a feel for how generic
Mixins work.
-<p/>
+</p>
+<p>
 Steps for this tutorial:
+</p>
 <ol>
     <li>Remove the HelloWorldStateMixin</li>
     <li>Add a GenericPropertyMixin, and have it implement InvocationHandler</li>

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial9/HelloWorldComposite.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial9/HelloWorldComposite.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial9/HelloWorldComposite.java
index 5430a11..938d988 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial9/HelloWorldComposite.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial9/HelloWorldComposite.java
@@ -8,10 +8,11 @@ import org.qi4j.api.mixin.Mixins;
 /**
  * This Composite interface declares transitively
  * all the Fragments of the HelloWorld composite.
- * <p/>
+ * <p>
  * All standard declarations have been moved to
  * the StandardAbstractEntityComposite so we don't have to repeat
  * them in all Composites.
+ * </p>
  */
 @Mixins( { HelloWorldBehaviourMixin.class, GenericPropertyMixin.class } )
 public interface HelloWorldComposite

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial9/HelloWorldState.java
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial9/HelloWorldState.java
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial9/HelloWorldState.java
index ada7eb4..51aee06 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial9/HelloWorldState.java
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial9/HelloWorldState.java
@@ -6,9 +6,10 @@ import org.qi4j.library.constraints.annotation.NotEmpty;
 /**
  * This interface contains only the state
  * of the HelloWorld object.
- * <p/>
+ * <p>
  * The state is declared using Properties. The @NotEmpty annotation is applied to the
  * method to check that the properties are not set to empty strings.
+ * </p>
  */
 public interface HelloWorldState
 {

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial9/package.html
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial9/package.html
b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial9/package.html
index 93b3387..ea21e57 100644
--- a/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial9/package.html
+++ b/tutorials/composites/src/main/java/org/qi4j/tutorials/composites/tutorial9/package.html
@@ -1,11 +1,12 @@
 <body>
 <h1>Tutorial 9 - Private and abstract mixins</h1>
-
+<p>
 Now we're going to turn around and see how we can reduce the code needed to implement the
 HelloWorld example. We will also look at how to hide the Properties from the client code,
 since Properties are often considered to be implementation details that should not be exposed
 to clients.
-<p/>
+</p>
+<p>
 The first thing we will do is remove the behaviour interface, and move the say() method
 to the TransientComposite type. This forces the mixin to implement the TransientComposite
type, which would
 normally mean that it would have to implement all methods, including those found in the TransientComposite
@@ -17,7 +18,8 @@ only map it to that specific method. In order to instantiate the Mixin it
will g
 which implements the remaining methods in the TransientComposite type, as no-ops. These will
never be called however,
 and is there purely for the purpose of being able to instantiate the Mixin. The Mixin is
considered
 to be an Abstract Fragment.
-<p/>
+</p>
+<p>
 To hide the state from the client we need to use what is called Private Mixins. A Private
Mixin is
 any mixin that is referenced by another Mixin by using the @This injection, but which is
not included
 in the TransientComposite type. As long as there is a Mixin implementation declared for the
interface specified
@@ -26,13 +28,16 @@ it is not extended by the TransientComposite type there is no way for
a user of
 That
 Mixin becomes an implementation detail. This can be used either for encapsulation purposes,
or for referencing
 utility mixins that help the rest of the code implement some interface, but which itself
should not be exposed.
-<p/>
+</p>
+<p>
 Since the state is now hidden the initialization of the TransientComposite is a bit more
tricky. Instead of just
 instantiating it you have to create a TransientBuilder first, then set the state using .prototypeFor(),
and then
 call newInstance(). This ensures that the state can be set during construction, but not at
any later point, other
 than through publicly exposed methods.
-<p/>
+</p>
+<p>
 Steps for this tutorial:
+</p>
 <ol>
     <li>Move the say() method into the TransientComposite interface.</li>
     <li>Remove the behaviour interface.</li>

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/composites/src/main/javadoc/overview.html
----------------------------------------------------------------------
diff --git a/tutorials/composites/src/main/javadoc/overview.html b/tutorials/composites/src/main/javadoc/overview.html
index bd78ee6..cc4b5de 100644
--- a/tutorials/composites/src/main/javadoc/overview.html
+++ b/tutorials/composites/src/main/javadoc/overview.html
@@ -8,20 +8,21 @@ Description of tutorials.
 <h2>Qi4j tutorials</h2>
 
 <h3>Composite tutorials</h3>
-
+<p>
 Throughout this set of tutorials it will be shown how to create and work with Composites,
which
 is the basic element in Qi4j. We will refactor one HelloWorld class to take advantage of
the various
 features in Qi4j. These refactorings will make it easier to reuse parts of the class,
 and introduce new features without having to change existing code. We will also look
 at some of the existing classes, or Fragments, available in Qi4j that you can reuse
 so that you don't have to write everything yourself.
-<p/>
+</p>
+<p>
 Each tutorial in this series starts with the result from the previous tutorial, so you can
 always look at the next tutorial step for guidance on what to do.
-
+</p>
 <h2>Related Documentation</h2>
-
+<p>
 For more information on Qi4j see <a target="_blank" href="http://www.qi4j.org">the
website</a>.
-
+</p>
 </body>
 </html>

http://git-wip-us.apache.org/repos/asf/zest-qi4j/blob/3bf71dfe/tutorials/hello/src/main/java/org/qi4j/tutorials/hello/Hello.java
----------------------------------------------------------------------
diff --git a/tutorials/hello/src/main/java/org/qi4j/tutorials/hello/Hello.java b/tutorials/hello/src/main/java/org/qi4j/tutorials/hello/Hello.java
index b8cee65..6a716a7 100644
--- a/tutorials/hello/src/main/java/org/qi4j/tutorials/hello/Hello.java
+++ b/tutorials/hello/src/main/java/org/qi4j/tutorials/hello/Hello.java
@@ -24,7 +24,6 @@ import org.qi4j.library.constraints.annotation.NotEmpty;
 /**
  * This Composite interface declares a simple "Hello World" interface with a single say()
method. What is being
  * said is defined in the HelloWorldState interface, which is a private mixin.
- * <p/>
  */
 @Mixins( { Hello.HelloWorldMixin.class } )
 public interface Hello


Mime
View raw message