Create a Concern

Concerns are defined in Concern.

If you want to reproduce what’s explained in this tutorial, remember to depend on the Core Bootstrap artifact:

Table 10. Artifact

Group ID	Artifact ID	Version
org.apache.polygene.core	org.apach e.polygene.core.bootstrap	3.1.0-SNAPSHOT

At runtime you will need the Core Runtime artifact too. See the Depend on Polygene™ tutorial for details.

Typed Concern

A typed Concern is a Java class that implements the MixinType it can be used on:

public class InventoryConcern extends ConcernOf<Order>
+  
Polygene™
Introduction
Tutorials
Javadoc
Samples
Core
Libraries
Extensions
Tools
Glossary 
Overview
Polygene™ in 2 minutes
Polygene™ in 10 minutes
Polygene™ in 30 minutes
Depend on Polygene™
Assemble an Application
Transient Composites Tutorial
S
 ervices Composites Tutorial
Use contextual fragments
Leverage Properties
Create a Constraint
Create a Concern
Create a SideEffect
Create an Entity
Configure a Service
Use @Invocation
Polygene™ Build System
Polygene™ Documentation
Releasing Polygene™
Create a Concern
Concerns are defined in Concern.
If you want to reproduce what’s explained in this tutorial, remember to depend on the Core Bootstrap artifact:
Table 10. Artifact
Group ID Artifact ID Version
org.apache.polygene.co
 re org.apache.polygene.core.bootstrap 0

At runtime you will need the Core Runtime artifact too. See the Depend on Polygene™ tutorial for details.
Typed Concern
A typed Concern is a Java class that implements the MixinType it can be used on:
public class InventoryConcern extends ConcernOf<Order>
     implements Order
 {
     @Service
@@ -103,7 +103,7 @@ public interface Order
 
       [...snip...]
 
-
Methods of the Concern Fragment will be called before the Mixin invocation.
Generic Concern
A generic Concern is a Java class that implements java.lang.reflect.InvocationHandler which allows it to be used on any
+

Group ID	Artifact ID	Version
org.apache.polygene.co re	org.apache.polygene.core.bootstrap	0

Methods of the Concern Fragment will be called before the Mixin invocation.

Generic Concern

A generic Concern is a Java class that implements java.lang.reflect.InvocationHandler which allows it to be used on any arbitrary MixinType.

public class MyGenericConcern extends GenericConcern
 {
     @Override
@@ -125,7 +125,7 @@ public interface AnyMixinType
 
     void doSomethingElse();
 
-

Methods of the Concern Fragment will be called before the Mixin invocation.

AppliesTo

For generic Concerns that should only trigger on methods with specific annotations or fulfilling some expression, add +

Methods of the Concern Fragment will be called before the Mixin invocation.

AppliesTo

For generic Concerns that should only trigger on methods with specific annotations or fulfilling some expression, add @AppliesTo annotation to the Concern class which points to either triggering annotation(s), or to AppliesToFilter implementation(s).

The Concern is invoked if one of the triggering annotations is found or one of the AppliesToFilter accepts the invocation. In other words the AppliesTo arguments are OR’ed.

Here is how the declaration goes ;

@AppliesTo( { MyAnnotation.class, MyAppliesToFilter.class } )

http://git-wip-us.apache.org/repos/asf/polygene-website/blob/538baaf6/content/java/develop/howto-create-constraint.html
----------------------------------------------------------------------
diff --git a/content/java/develop/howto-create-constraint.html b/content/java/develop/howto-create-constraint.html
index a94d56f..7ebd35f 100644
--- a/content/java/develop/howto-create-constraint.html
+++ b/content/java/develop/howto-create-constraint.html
@@ -1,5 +1,5 @@
 
-Create a Constraint
+Create a Constraint
 
 
 
@@ -66,7 +66,7 @@
   })();
  
 
-  
Polygene™
Introduction
Tutorials
Javadoc
Samples
Core
Libraries
Extensions
Tools
Glossary 
Overview
Polygene™ in 2 minutes
Polygene™ in 10 minutes
Polygene™ in 30 minutes
Depend on Polygene™
Assemble an Application
Transient Composites Tutorial
Services Composites Tutorial
Use contextual fragments
Leverage Properties
Create a Constraint
Create a Concern
Create a SideEffect
Create an Entity
Configure a Service
Use @Invocation
Polygene™ Build System
Polygene™ Documentation
Releasing Polygene™
Create a Constraint
Constraints are defined in Constraint.
If you want to reproduce what’s explained in this tutorial, remember to depend on the Core Bootstrap artifact:
Table 9. Artifact
Group ID Artifact ID Version
org.apache.polygene.core org.apache.polygene.core.bootstrap 3.1.0-SNAPSHOT

At runtime you will need the Core Runtime artifact too. See the Depend on Polygene™ tutorial for details.
Method Constraint
Method Constraints are declared with annotations on the method argument. The annotation itself is custom, and it is possible to make your own.
public interface Dialer
+  
Polygene™
Introduction
Tutorials
Javadoc
Samples
Core
Libraries
Extensions
Tools
Glossary 
Overview
Polygene™ in 2 minutes
Polygene™ in 10 minutes
Polygene™ in 30 minutes
Depend on Polygene™
Assemble an Application
Transient Composites Tutorial
S
 ervices Composites Tutorial
Use contextual fragments
Leverage Properties
Create a Constraint
Create a Concern
Create a SideEffect
Create an Entity
Configure a Service
Use @Invocation
Polygene™ Build System
Polygene™ Documentation
Releasing Polygene™
Create a Constraint
Constraints are defined in Constraint.
If you want to reproduce what’s explained in this tutorial, remember to depend on the Core Bootstrap artifact:
Table 9. Artifact
Group ID Artifact ID Version
org.apac
 he.polygene.core org.apache.polygene.core.bootstrap 0

At runtime you will need the Core Runtime artifact too. See the Depend on Polygene™ tutorial for details.
Method Constraint
Method Constraints are declared with annotations on the method argument. The annotation itself is custom, and it is possible to make your own.
public interface Dialer
 {
     void callPhoneNumber(@PhoneNumber String phoneNo);
 
@@ -120,7 +120,7 @@ in the method invocation. Concerns can be used to catch and report these violati
     {
     }
 }
-
Property Constraint
Property Constraints are declared on the Property method.
public interface HasPhoneNumber
+
Property Constraint
Property Constraints are declared on the Property method.
public interface HasPhoneNumber
 {
     @PhoneNumber
     Property<String> phoneNumber();

http://git-wip-us.apache.org/repos/asf/polygene-website/blob/538baaf6/content/java/develop/howto-create-entity.html
----------------------------------------------------------------------
diff --git a/content/java/develop/howto-create-entity.html b/content/java/develop/howto-create-entity.html
index 0eed607..157e9ed 100644
--- a/content/java/develop/howto-create-entity.html
+++ b/content/java/develop/howto-create-entity.html
@@ -1,5 +1,5 @@
 
-Create an Entity
+Create an Entity
 
 
 
@@ -66,19 +66,19 @@
   })();
  
 
-  
Polygene™
Introduction
Tutorials
Javadoc
Samples
Core
Libraries
Extensions
Tools
Glossary 
Overview
Polygene™ in 2 minutes
Polygene™ in 10 minutes
Polygene™ in 30 minutes
Depend on Polygene™
Assemble an Application
Transient Composites Tutorial
Services Composites Tutorial
Use contextual fragments
Leverage Properties
Create a Constraint
Create a Concern
Create a SideEffect
Create an Entity
Configure a Service
Use @Invocation
Polygene™ Build System
Polygene™ Documentation
Releasing Polygene™
Create an Entity
One of the most common tasks in Polygene™ is the management of the life cycle of Entities. Since Polygene™ is capable of
+  
Polygene™
Introduction
Tutorials
Javadoc
Samples
Core
Libraries
Extensions
Tools
Glossary 
Overview
Polygene™ in 2 minutes
Polygene™ in 10 minutes
Polygene™ in 30 minutes
Depend on Polygene™
Assemble an Application
Transient Composites Tutorial
S
 ervices Composites Tutorial
Use contextual fragments
Leverage Properties
Create a Constraint
Create a Concern
Create a SideEffect
Create an Entity
Configure a Service
Use @Invocation
Polygene™ Build System
Polygene™ Documentation
Releasing Polygene™
Create an Entity
One of the most common tasks in Polygene™ is the management of the life cycle of Entities. Since Polygene™ is capable of
 delivering much higher performance than traditional Object-Relational Mapping technologies, we also expect that people
-use Entities more frequently in Polygene™ applications, so it is a very important topic to cover.
If you want to reproduce what’s explained in this tutorial, remember to depend on the Core Bootstrap artifact:
Table 12. Artifact
Group ID Artifact ID Version
org.apache.polygene.core org.apache.polygene.core.bootstrap 3.1.0-SNAPSHOT

Moreover, you’ll need an EntityStore for persistence and an Indexing engine for querying. Cho
 ose among the available
-implementations listed in the Extensions section.
At runtime you will need the Core Runtime artifact too. See the Depend on Polygene™ tutorial for details.
Basics First
All Entity operations MUST be done within a UnitOfWork. UnitOfWorks can be nested and if underlying UnitOfWorks are not
+use Entities more frequently in Polygene™ applications, so it is a very important topic to cover.
If you want to reproduce what’s explained in this tutorial, remember to depend on the Core Bootstrap artifact:
Table 12. Artifact
Group ID Artifact ID Version
org.apache.polygene.core org.apache.polygene.core.bootstrap 0

Moreover, you’ll need an EntityStore for persistence and an Indexing engine for querying. Choose amo
 ng the available
+implementations listed in the Extensions section.
At runtime you will need the Core Runtime artifact too. See the Depend on Polygene™ tutorial for details.
Basics First
All Entity operations MUST be done within a UnitOfWork. UnitOfWorks can be nested and if underlying UnitOfWorks are not
 completed (method complete()), then none of the operations will be persisted permanently.
Entity composites are subtypes of the EntityComposite interface.
Domain code typically don’t need to know of the EntityComposite types directly, and is instead using the domain specific
 interface. The Visibility rules will be applied to associate the right EntityComposite when a domain type is requested.
 Ambiguities are not accepted and will result in runtime exceptions.
Polygene™ supports that each entity instance can have more than one entity type, and it is managed per instance. This feature
-is beyond the scope of this HowTO and will be covered subsequently.
Good Practice
We have made the observation that it is good practice to separate the internal state from the observable behavior. By
+is beyond the scope of this HowTO and will be covered subsequently.
Good Practice
We have made the observation that it is good practice to separate the internal state from the observable behavior. By
 this we mean that it is not a good practice to allow client code to manipulate or even view the internal states of
 objects, which is such a common (bad) practice in the so called POJO world.
Instead, we recommend that the programmer defines the client requirement of what each participant within the client
 context needs to conform to, and then create composites accordingly and hide all the state internal to the composite in
 private mixins. By doing so, the same entity can participate in multiple contexts with different behavioral requirements
-but using the same internal state.
We recommend limited use of primitive types for Properties and instead subtype the Property.
And try to use ValueComposites instead of Entities.
The Entity
We need an entity to illustrate how we recommend to separate internal state from public behavior and observable state.
+but using the same internal state.
We recommend limited use of primitive types for Properties and instead subtype the Property.
And try to use ValueComposites instead of Entities.
The Entity
We need an entity to illustrate how we recommend to separate internal state from public behavior and observable state.
 We will for the sake of simplicity use a trivial example. Please refer to other (possibly future) HowTos on patterns on
 Entity management.
public interface Car
 {
@@ -118,7 +118,7 @@ Accidents.
We will also need to define the composites for the above domain
 {}
 
 
For this case, we define both the Car and the Manufacturer as Entities, whereas the Accident is a Value, since it is an
-immutable event that can not be modified.
Assembly
All of the above must also be declared in the assembly. We MUST associate the EntityComposites with a relevant Module.
+immutable event that can not be modified.
Assembly
All of the above must also be declared in the assembly. We MUST associate the EntityComposites with a relevant Module.
 We must also assemble an EntityStore for the entire application, but that is outside the scope of this HowTo.
public class MyAssembler
     implements Assembler
 {
@@ -133,7 +133,7 @@ We must also assemble an EntityStore for the entire application, but that is out
     }
 }
 
We have no other Composites involved yet, so we can proceed to look at the usage code.
We recommend that the life cycle management of entities is placed inside domain factories, one for each type and made
-available as services.
The Entity Factory
The entity factory is something you need to write yourself, but as with most things in Polygene™ it will end up being a
+available as services.
The Entity Factory
The entity factory is something you need to write yourself, but as with most things in Polygene™ it will end up being a
 fairly small implementation. So how is that done?
public interface CarEntityFactory
 {
     Car create(Manufacturer manufacturer, String model);
@@ -231,7 +231,7 @@ Services to be available to the application layer above, and not restricted to w
         ).visibleIn( Visibility.application );
     }
 }
-
The UnitOfWork
If you notice, there is a couple of calls to Module.currentUnitOfWork(), but what is current UnitOfWork, and
+
The UnitOfWork
If you notice, there is a couple of calls to Module.currentUnitOfWork(), but what is current UnitOfWork, and
 who is setting that up?
Well, the domain layer should not worry about UoW, it is probably the responsibility of the application/service layer
 sitting on top. That could be a web application creating and completing a UoW per request, or some other co-ordinator
 doing long-running UnitOfWorks.
There are of course a lot more details to get all this completed, but that is beyond the scope of this HowTo.

http://git-wip-us.apache.org/repos/asf/polygene-website/blob/538baaf6/content/java/develop/howto-create-sideeffect.html
----------------------------------------------------------------------
diff --git a/content/java/develop/howto-create-sideeffect.html b/content/java/develop/howto-create-sideeffect.html
index 2ad1e90..d16a0ab 100644
--- a/content/java/develop/howto-create-sideeffect.html
+++ b/content/java/develop/howto-create-sideeffect.html
@@ -1,5 +1,5 @@
 
-Create a SideEffect
+Create a SideEffect
 
 
 
@@ -66,7 +66,7 @@
   })();
  
 
-  
Polygene™
Introduction
Tutorials
Javadoc
Samples
Core
Libraries
Extensions
Tools
Glossary 
Overview
Polygene™ in 2 minutes
Polygene™ in 10 minutes
Polygene™ in 30 minutes
Depend on Polygene™
Assemble an Application
Transient Composites Tutorial
Services Composites Tutorial
Use contextual fragments
Leverage Properties
Create a Constraint
Create a Concern
Create a SideEffect
Create an Entity
Configure a Service
Use @Invocation
Polygene™ Build System
Polygene™ Documentation
Releasing Polygene™
Create a SideEffect
SideEffects are defined in SideEffect.
If you want to reproduce what’s explained in this tutorial, remember to depend on the Core Bootstrap artifact:
Table 11. Artifact
Group ID Artifact ID Version
org.apache.polygene.core org.apache.polygene.core.bootstrap 3.1.0-SNAPSHOT

At runtime you will need the Core Runtime artifact too. See the Depend on Polygene™ tutorial for details.
Typed SideEffect
A typed SideEffect is a Java class that implements the MixinType it can be used on:
public abstract class MailNotifySideEffect extends SideEffectOf<Confirmable>
+  
Polygene™
Introduction
Tutorials
Javadoc
Samples
Core
Libraries
Extensions
Tools
Glossary 
Overview
Polygene™ in 2 minutes
Polygene™ in 10 minutes
Polygene™ in 30 minutes
Depend on Polygene™
Assemble an Application
Transient Composites Tutorial
S
 ervices Composites Tutorial
Use contextual fragments
Leverage Properties
Create a Constraint
Create a Concern
Create a SideEffect
Create an Entity
Configure a Service
Use @Invocation
Polygene™ Build System
Polygene™ Documentation
Releasing Polygene™
Create a SideEffect
SideEffects are defined in SideEffect.
If you want to reproduce what’s explained in this tutorial, remember to depend on the Core Bootstrap artifact:
Table 11. Artifact
Group ID Artifact ID Version
org.apa
 che.polygene.core org.apache.polygene.core.bootstrap 0

At runtime you will need the Core Runtime artifact too. See the Depend on Polygene™ tutorial for details.
Typed SideEffect
A typed SideEffect is a Java class that implements the MixinType it can be used on:
public abstract class MailNotifySideEffect extends SideEffectOf<Confirmable>
     implements Confirmable
 {
     @Service
@@ -107,7 +107,7 @@ public interface OrderEntity
             HasLineItems, Confirmable, HasIdentity
 {
 }
-
Methods of the SideEffect Fragment will be called after the Mixin invocation.
Generic SideEffect
A generic SideEffect is a Java class that implements java.lang.reflect.InvocationHandler which allows it to be used on any
+
Methods of the SideEffect Fragment will be called after the Mixin invocation.
Generic SideEffect
A generic SideEffect is a Java class that implements java.lang.reflect.InvocationHandler which allows it to be used on any
 arbitrary MixinType.
public class MyGenericSideEffect extends GenericSideEffect
 {
     @Override
@@ -134,7 +134,7 @@ public interface AnyMixinType
   [...snip...]
 
 }
-
Methods of the SideEffect Fragment will be called before the Mixin invocation.
AppliesTo
For generic SideEffects that should only trigger on methods with specific annotations or fulfilling some expression, add
+
Methods of the SideEffect Fragment will be called before the Mixin invocation.
AppliesTo
For generic SideEffects that should only trigger on methods with specific annotations or fulfilling some expression, add
 @AppliesTo annotation to the SideEffect class which points to either triggering annotation(s), or to AppliesToFilter
 implementation(s).
The SideEffect is invoked if one of the triggering annotations is found or one of the AppliesToFilter accepts the
 invocation. In other words the AppliesTo arguments are OR’ed.
Here is how the declaration goes ;
@AppliesTo( { MyAnnotation.class, MyAppliesToFilter.class } )

http://git-wip-us.apache.org/repos/asf/polygene-website/blob/538baaf6/content/java/develop/howto-depend-on-polygene.html
----------------------------------------------------------------------
diff --git a/content/java/develop/howto-depend-on-polygene.html b/content/java/develop/howto-depend-on-polygene.html
index d8df773..9585137 100644
--- a/content/java/develop/howto-depend-on-polygene.html
+++ b/content/java/develop/howto-depend-on-polygene.html
@@ -1,5 +1,5 @@
 
-Depend on Polygene™
+Depend on Polygene™
 
 
 
@@ -66,9 +66,9 @@
   })();
  
 
-  
Polygene™
Introduction
Tutorials
Javadoc
Samples
Core
Libraries
Extensions
Tools
Glossary 
Overview
Polygene™ in 2 minutes
Polygene™ in 10 minutes
Polygene™ in 30 minutes
Depend on Polygene™
Assemble an Application
Transient Composites Tutorial
Services Composites Tutorial
Use contextual fragments
Leverage Properties
Create a Constraint
Create a Concern
Create a SideEffect
Create an Entity
Configure a Service
Use @Invocation
Polygene™ Build System
Polygene™ Documentation
Releasing Polygene™
Depend on Polygene™
Note
Some of the Libraries and Extensions depend on artifacts that are not deployed in central, you’ll need to
-add other repositories to your build scripts accordingly.
Release artifacts, including sources and javadoc, are deployed to Maven Central:
http://repo1.maven.org/maven2/ (US)
http://uk.maven.org/maven2/ (Europe)
Snapshot artifacts, including sources and javadoc, are built against the develop branch and deployed weekly to the Apache SNAPSHOTS repository:
http://repository.apache.org/snapshots/
Manually
If you don’t rely on your build scripts dependency resolution mechanism you should
-download the SDK distribution.
Using Maven
You simply declare dependencies on Polygene™ artifacts:
<dependencies>
+  
Polygene™
Introduction
Tutorials
Javadoc
Samples
Core
Libraries
Extensions
Tools
Glossary 
Overview
Polygene™ in 2 minutes
Polygene™ in 10 minutes
Polygene™ in 30 minutes
Depend on Polygene™
Assemble an Application
Transient Composites Tutorial
Services Composites Tutorial
Use contextual fragments
Leverage Properties
Create a Constraint
Create a Concern
Create a SideEffect
Create an Entity
Configure a Service
Use @Invocation
Polygene™ Build System
Polygene™ Documentation
Releasing Polygene™
Depend on Polygene™
Note
Some of the Libraries and Extensions depend on artifacts that are not deployed in central, you’ll need to
+add other repositories to your build scripts accordingly.
Release artifacts, including sources and javadoc, are deployed to Maven Central:
http://repo1.maven.org/maven2/ (US)
http://uk.maven.org/maven2/ (Europe)
Snapshot artifacts, including sources and javadoc, are built against the develop branch and deployed weekly to the Apache SNAPSHOTS repository:
http://repository.apache.org/snapshots/
Manually
If you don’t rely on your build scripts dependency resolution mechanism you should
+download the SDK distribution.
Using Maven
You simply declare dependencies on Polygene™ artifacts:
<dependencies>
     <dependency>
         <groupId>org.apache.polygene.core</groupId>
         <artifactId>org.apache.polygene.core.bootstrap</artifactId>
@@ -93,15 +93,15 @@ add other repositories to your build scripts accordingly.
Release ar
         <releases><enabled>false</enabled></releases>
         <snapshots><enabled>true</enabled></snapshots>
     </repository>
-</repositories>
Using Gradle
You simply declare dependencies on Polygene™ artifacts:
dependencies {
+</repositories>
Using Gradle
You simply declare dependencies on Polygene™ artifacts:
dependencies {
     compile     "org.apache.polygene.core:org.apache.polygene.core.bootstrap:POLYGENE_VERSION"
     runtime     "org.apache.polygene.core:org.apache.polygene.core.runtime:POLYGENE_VERSION"
     testCompile "org.apache.polygene.core:org.apache.polygene.core.testsupport:POLYGENE_VERSION"
 }
Where POLYGENE_VERSION is the Polygene™ version you want to use.
If you want to use -SNAPSHOT versions, you need to register the Apache Snapshots repository:
repositories {
     maven { name 'apache-snapshots'; url "https://repository.apache.org/snapshots/" }
-}
Using Buildr
You simply declare dependencies on Polygene™ artifacts:
compile.with 'org.apache.polygene.core:org.apache.polygene.core.bootstrap:POLYGENE_VERSION'
+}
Using Buildr
You simply declare dependencies on Polygene™ artifacts:
compile.with 'org.apache.polygene.core:org.apache.polygene.core.bootstrap:POLYGENE_VERSION'
 package(:war).with :libs => 'org.apache.polygene.core:org.apache.polygene.core.runtime:POLYGENE_VERSION'
-test.with 'org.apache.polygene.core:org.apache.polygene.core.testsupport:POLYGENE_VERSION'
Where POLYGENE_VERSION is the Polygene™ version you want to use.
If you want to use -SNAPSHOT versions, you need to register the Apache Snapshots repository:
repositories.remote << 'https://repository.apache.org/snapshots/'
Using SBT
You simply declare dependencies on Polygene™ artifacts:
libraryDependencies += \
+test.with 'org.apache.polygene.core:org.apache.polygene.core.testsupport:POLYGENE_VERSION'
Where POLYGENE_VERSION is the Polygene™ version you want to use.
If you want to use -SNAPSHOT versions, you need to register the Apache Snapshots repository:
repositories.remote << 'https://repository.apache.org/snapshots/'
Using SBT
You simply declare dependencies on Polygene™ artifacts:
libraryDependencies += \
     "org.apache.polygene.core" % "org.apache.polygene.core.bootstrap" % "POLYGENE_VERSION" \
     withSources() withJavadoc()
 libraryDependencies += \
@@ -109,7 +109,7 @@ libraryDependencies += \
     withSources() withJavadoc()
 libraryDependencies += \
     "org.apache.polygene.core" % "org.apache.polygene.core.testsupport" % "POLYGENE_VERSION" % "test" \
-    withSources() withJavadoc()
Where POLYGENE_VERSION is the Polygene™ version you want to use.
If you want to use -SNAPSHOT versions, you need to register the Apache Snapshots repository:
resolvers += "apache-snapshots" at "https://repository.apache.org/snapshots/"
Using Ivy
You simply declare dependencies on Polygene™ artifacts:
<ivy-module>
+    withSources() withJavadoc()
Where POLYGENE_VERSION is the Polygene™ version you want to use.
If you want to use -SNAPSHOT versions, you need to register the Apache Snapshots repository:
resolvers += "apache-snapshots" at "https://repository.apache.org/snapshots/"
Using Ivy
You simply declare dependencies on Polygene™ artifacts:
<ivy-module>
     <dependencies>
         <dependency org="org.apache.polygene.core" name="org.apache.polygene.core.bootstrap"
                     rev="POLYGENE_VERSION"  conf="default" />

http://git-wip-us.apache.org/repos/asf/polygene-website/blob/538baaf6/content/java/develop/howto-invocation-annotation.html
----------------------------------------------------------------------
diff --git a/content/java/develop/howto-invocation-annotation.html b/content/java/develop/howto-invocation-annotation.html
index 1765b4a..90920d3 100644
--- a/content/java/develop/howto-invocation-annotation.html
+++ b/content/java/develop/howto-invocation-annotation.html
@@ -1,5 +1,5 @@
 
-Use @Invocation
+Use @Invocation
 
 
 
@@ -66,11 +66,11 @@
   })();
  
 
-  
Polygene™
Introduction
Tutorials
Javadoc
Samples
Core
Libraries
Extensions
Tools
Glossary 
Overview
Polygene™ in 2 minutes
Polygene™ in 10 minutes
Polygene™ in 30 minutes
Depend on Polygene™
Assemble an Application
Transient Composites Tutorial
Services Composites Tutorial
Use contextual fragments
Leverage Properties
Create a Constraint
Create a Concern
Create a SideEffect
Create an Entity
Configure a Service
Use @Invocation
Polygene™ Build System
Polygene™ Documentation
Releasing Polygene™
Use @Invocation
The @Invocation annotation is relatively unknown but can be rather powerful to use, especially when creating
+  
Polygene™
Introduction
Tutorials
Javadoc
Samples
Core
Libraries
Extensions
Tools
Glossary 
Overview
Polygene™ in 2 minutes
Polygene™ in 10 minutes
Polygene™ in 30 minutes
Depend on Polygene™
Assemble an Application
Transient Composites Tutorial
S
 ervices Composites Tutorial
Use contextual fragments
Leverage Properties
Create a Constraint
Create a Concern
Create a SideEffect
Create an Entity
Configure a Service
Use @Invocation
Polygene™ Build System
Polygene™ Documentation
Releasing Polygene™
Use @Invocation
The @Invocation annotation is relatively unknown but can be rather powerful to use, especially when creating
 libraries that needs to be flexible of what the user needs to do.
@Invocation is a different InjectionScope, which is a concept to tell Polygene runtime where to look for the
 instances to be injected. Other, more well-known, InjectionScope annotations are @This, @Structure and
 @Service.
The @Invocation injection scope can provide the following types, all related to the on-going method invocation,
-which is especially useful in Generic Concerns or Generic Mixins;

+which is especially useful in Generic Concerns or Generic Mixins;

 java.lang.reflect.Method - The current method being invoked.
 

 java.lang.reflect.AnnotatedElement - An descriptor for all annotations of the Method.
@@ -78,11 +78,11 @@ which is especially useful in Generic Concerns or Generic Mixins;
Custom Annotations - Your own annotation type.
 

 java.util.Iterable<Method> - An iterable of all declared methods of the composite type.
-
java.lang.reflect.Method
This injection will simply provide the java.lang.reflect.Method of the on-going call. For generic fragments that
+
java.lang.reflect.Method
This injection will simply provide the java.lang.reflect.Method of the on-going call. For generic fragments that
 will be the same as the second argument in the java.lang.reflect.InvocationHandler.invoke() method. Sometimes
-it is useful to obtain this for typed fragment as well, to reduce names in Strings.
java.lang.reflect.AnnotatedElement
This Reflection API class encapsulates the annotation aspect of any element that can be annotated. Polygene implements
+it is useful to obtain this for typed fragment as well, to reduce names in Strings.
java.lang.reflect.AnnotatedElement
This Reflection API class encapsulates the annotation aspect of any element that can be annotated. Polygene implements
 this interface for the Composite. That means that annotations for both the method as well as the composite is provided
-through this injection.
Custom Annotations
It is often useful to introduce one’s own annotations, especially for libraries, and use these annotations to direct
+through this injection.
Custom Annotations
It is often useful to introduce one’s own annotations, especially for libraries, and use these annotations to direct
 the runtime to do different things. Many of the "built-in" features in Polygene is actually done by this mechanism and
 not directly implemented in the Core Runtime.
First create an annotation of your own liking, it must have java.lang.annotation.Retention set to RUNTIME
@Retention( RUNTIME )
 @interface Foo
@@ -100,7 +100,7 @@ not directly implemented in the Core Runtime.
First create an annotation o
 {
     @Invocation
     Foo foo;
-
java.util.Iterable<Method>
This injection will provide all the declared methods of the current composite. This is particularly useful for mixins
+
java.util.Iterable<Method>
This injection will provide all the declared methods of the current composite. This is particularly useful for mixins
 or concerns that builds information about the composite they belong to.

         Copyright © 2015 The Apache Software Foundation, Licensed under the Apache License, Version 2.0.