You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@polygene.apache.org by ni...@apache.org on 2015/04/17 18:08:31 UTC
[19/50] [abbrv] zest-qi4j git commit: Fixed all JavaDoc ERRORS
reported by DocLint in Java 8.
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<String> 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>
@State Property<String> 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