directory-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From elecha...@apache.org
Subject [directory-ldap-api] branch master updated: Last batch of Javadoc fixing: we now don't have anymore error or warnings when building the LDAP API javadoc.
Date Tue, 07 Aug 2018 03:24:11 GMT
This is an automated email from the ASF dual-hosted git repository.

elecharny pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/directory-ldap-api.git


The following commit(s) were added to refs/heads/master by this push:
     new 0b91376  Last batch of Javadoc fixing: we now don't have anymore error or warnings when building the LDAP API javadoc.
0b91376 is described below

commit 0b91376ab5ec8cccf896453b691b033999026bbb
Author: Emmanuel L├ęcharny <elecharny@symas.com>
AuthorDate: Tue Aug 7 05:24:07 2018 +0200

    Last batch of Javadoc fixing: we now don't have anymore error or
    warnings when building the LDAP API javadoc.
---
 .../directory/api/ldap/util/tree/DnNode.java       |   1 +
 .../src/main/antlr/SubtreeSpecificationChecker.g   |   4 +-
 ldap/model/src/main/antlr/distinguishedName.g      | 129 ++++++-
 ldap/model/src/main/antlr/subtree-specification.g  |   4 +-
 .../ldap/model/entry/ModificationOperation.java    |   2 +
 .../api/ldap/model/ldif/LdifRevertor.java          |  24 +-
 .../api/ldap/model/message/AliasDerefMode.java     |   1 +
 .../model/message/extended/NoticeOfDisconnect.java |   2 +
 .../api/ldap/model/name/ComplexDnParser.java       |   3 +
 .../apache/directory/api/ldap/model/name/Dn.java   |   4 +
 .../api/ldap/model/name/FastDnParser.java          |   7 +-
 .../apache/directory/api/ldap/model/name/Rdn.java  |   7 +
 .../api/ldap/model/password/PasswordUtil.java      |  16 +
 .../api/ldap/model/schema/DescriptionUtils.java    |   3 +
 .../ldap/model/schema/MatchingRuleTypeEnum.java    |   2 +
 .../api/ldap/model/schema/PrepareString.java       |   6 +
 .../api/ldap/model/schema/SchemaErrorHandler.java  |   4 +
 .../ldap/model/schema/SchemaObjectRenderer.java    |   2 +
 .../api/ldap/model/schema/SchemaObjectType.java    |   2 +
 .../api/ldap/model/schema/SyntaxChecker.java       |   2 +
 .../schema/comparators/IntegerComparator.java      |  70 ++--
 .../ObjectIdentifierFirstComponentComparator.java  |   3 +
 .../comparators/TelephoneNumberComparator.java     |   3 +
 .../model/schema/parsers/OpenLdapSchemaParser.java | 397 ++++++++++++++++++++-
 .../ldap/model/schema/registries/Registries.java   |  17 +
 .../registries/helper/AttributeTypeHelper.java     |  42 ++-
 .../registries/helper/ObjectClassHelper.java       |  12 +
 .../FacsimileTelephoneNumberSyntaxChecker.java     |   8 +
 .../schema/syntaxCheckers/OidLenSyntaxChecker.java |   3 +-
 .../syntaxCheckers/OtherMailboxSyntaxChecker.java  |   2 +
 .../schema/syntaxCheckers/RegexSyntaxChecker.java  |   1 +
 .../SubtreeSpecificationSyntaxChecker.java         |   1 +
 .../TelephoneNumberSyntaxChecker.java              |   1 +
 .../api/ldap/model/subtree/AdministrativeRole.java |   2 +
 .../ReusableAntlrSubtreeSpecificationChecker.java  |   2 +
 .../ReusableAntlrSubtreeSpecificationParser.java   |   2 +
 .../model/subtree/SubtreeSpecificationParser.java  |   6 +-
 .../directory/api/ldap/model/url/LdapUrl.java      |  28 +-
 .../schema/comparators/IntegerComparatorTest.java  |  81 +++++
 39 files changed, 835 insertions(+), 71 deletions(-)

diff --git a/ldap/extras/util/src/main/java/org/apache/directory/api/ldap/util/tree/DnNode.java b/ldap/extras/util/src/main/java/org/apache/directory/api/ldap/util/tree/DnNode.java
index 129cc72..da7ed48 100644
--- a/ldap/extras/util/src/main/java/org/apache/directory/api/ldap/util/tree/DnNode.java
+++ b/ldap/extras/util/src/main/java/org/apache/directory/api/ldap/util/tree/DnNode.java
@@ -161,6 +161,7 @@ public class DnNode<N>
      * @param element The element to set
      * @param nbRdns The number of RDNs in the Dn
      * @param nbRdns The number of level to create
+     * @return The created Node
      * @throws LdapException If the Dn is null or empty
      */
     private DnNode<N> createNode( Dn dn, N element, int nbRdns ) throws LdapException
diff --git a/ldap/model/src/main/antlr/SubtreeSpecificationChecker.g b/ldap/model/src/main/antlr/SubtreeSpecificationChecker.g
index d08861e..991b26f 100644
--- a/ldap/model/src/main/antlr/SubtreeSpecificationChecker.g
+++ b/ldap/model/src/main/antlr/SubtreeSpecificationChecker.g
@@ -78,7 +78,9 @@ options
     private SchemaManager schemaManager;
 
     /**
-     * Initiaize the checker
+     * Initialize the checker
+     *
+     * @param schemaManager the SchemaManager instance
      */
     public void init( SchemaManager schemaManager )
     {
diff --git a/ldap/model/src/main/antlr/distinguishedName.g b/ldap/model/src/main/antlr/distinguishedName.g
index e372565..14b22d9 100644
--- a/ldap/model/src/main/antlr/distinguishedName.g
+++ b/ldap/model/src/main/antlr/distinguishedName.g
@@ -97,6 +97,7 @@ UTFMB : '\u0080'..'\uFFFE' ;
 
 /**
  * RFC 4514, Section 3:
+ * <pre>
  * LUTF1 = %x01-1F / %x21 / %x24-2A / %x2D-3A /
  *    %x3D / %x3F-5B / %x5D-7F
  *
@@ -108,6 +109,12 @@ UTFMB : '\u0080'..'\uFFFE' ;
  *   UNDERSCORE (0x5F)
  *   DIGIT (0x30-0x39)
  *   ALPHA (0x41-0x5A and 0x61-0x7A)
+ * </pre>
+ *
+ * @param _createToken If a Token is to be to created
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
+ * @throws CharStreamException If we can't process the stream
  */
 CHAR_REST : 
     '\u0001'..'\u001F' |
@@ -164,14 +171,19 @@ options    {
  * Parses a Dn string.
  *
  * RFC 4514, Section 3
+ * <pre>
  * distinguishedName = [ relativeDistinguishedName
  *     *( COMMA relativeDistinguishedName ) ]
+ * </pre>
  *
  * RFC 2253, Section 3
+ * <pre>
  * distinguishedName = [name] 
  * name       = name-component *("," name-component)
+ * </pre>
  *
  * RFC 1779, Section 2.3
+ * <pre>
  * &lt;name&gt; ::= &lt;name-component&gt; ( &lt;spaced-separator&gt; )
  *        | &lt;name-component&gt; &lt;spaced-separator&gt; &lt;name&gt;
  * &lt;spaced-separator&gt; ::= &lt;optional-space&gt;
@@ -179,6 +191,12 @@ options    {
  *             &lt;optional-space&gt;
  * &lt;separator&gt; ::=  "," | ";"
  * &lt;optional-space&gt; ::= ( &lt;CR&gt; ) *( " " )
+ * </pre>
+ *
+ * @param schemaManager The SchemaManager
+ * @param dn The Dn to update
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
  */
 distinguishedName [SchemaManager schemaManager, Dn dn]
     {
@@ -225,14 +243,19 @@ distinguishedName [SchemaManager schemaManager, Dn dn]
  * Parses a Dn string.
  *
  * RFC 4514, Section 3
+ * <pre>
  * distinguishedName = [ relativeDistinguishedName
  *     *( COMMA relativeDistinguishedName ) ]
+ * </pre>
  *
  * RFC 2253, Section 3
+ * <pre>
  * distinguishedName = [name] 
  * name       = name-component *("," name-component)
+ * </pre>
  *
  * RFC 1779, Section 2.3
+ * <pre>
  * &lt;name&gt; ::= &lt;name-component&gt; ( &lt;spaced-separator&gt; )
  *        | &lt;name-component&gt; &lt;spaced-separator&gt; &lt;name&gt;
  * &lt;spaced-separator&gt; ::= &lt;optional-space&gt;
@@ -240,7 +263,13 @@ distinguishedName [SchemaManager schemaManager, Dn dn]
  *             &lt;optional-space&gt;
  * &lt;separator&gt; ::=  "," | ";"
  * &lt;optional-space&gt; ::= ( &lt;CR&gt; ) *( " " )
+ * </pre>
  *
+ * @param schemaManager The SchemaManager
+ * @param rdns The list of Rdns to update
+ * @return The normalized Dn
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
  */
 relativeDistinguishedNames [SchemaManager schemaManager, List<Rdn> rdns] returns [String normNameStr]
     {
@@ -277,17 +306,27 @@ relativeDistinguishedNames [SchemaManager schemaManager, List<Rdn> rdns] returns
  * Parses a Rdn string.
  *
  * RFC 4514, Section 3
+ * <pre>
  * relativeDistinguishedName = attributeTypeAndValue
  *     *( PLUS attributeTypeAndValue )
+ * </pre>
  *
  * RFC 2253, Section 3
+ * <pre>
  * name-component = attributeTypeAndValue *("+" attributeTypeAndValue)
+ * </pre>
  *
  * RFC 1779, Section 2.3
+ * <pre>
  * &lt;name-component&gt; ::= &lt;attribute&gt;
  *     | &lt;attribute&gt; &lt;optional-space&gt; "+"
  *       &lt;optional-space&gt; &lt;name-component&gt;
+ * </pre>
  *
+ * @param schemaManager The SchemaManager
+ * @param rdn The Rdn to update
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
  */
 relativeDistinguishedName [SchemaManager schemaManager, Rdn rdn]
     {
@@ -398,11 +437,20 @@ relativeDistinguishedName [SchemaManager schemaManager, Rdn rdn]
 
 /**
  * RFC 4514, Section 3
+ * <pre>
  * attributeTypeAndValue = attributeType EQUALS attributeValue
+ * </pre>
  *
  * RFC 2253, Section 3
+ * <pre>
  * attributeTypeAndValue = attributeType "=" attributeValue
+ * </pre>
  *
+ * @param schemaManager The SchemaManager
+ * @param rdn The Rdn to update
+ * @return The user provided Ava
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
  */
 attributeTypeAndValue [SchemaManager schemaManager, Rdn rdn] returns [String upNameStr]
     {
@@ -500,9 +548,14 @@ attributeTypeAndValue [SchemaManager schemaManager, Rdn rdn] returns [String upN
 /**
  * RFC 4514 Section 3
  *
+ * <pre>
  * attributeType = descr / numericoid
+ * </pre>
  *
- */    
+ * @return The AttributeType
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
+ */
 attributeType returns [String attributeType]
     {
         matchedProduction( "attributeType()" );
@@ -519,14 +572,19 @@ attributeType returns [String attributeType]
 /**
  * RFC 4512 Section 1.4
  *
+ * <pre>
  * descr = keystring
  * keystring = leadkeychar *keychar
  * leadkeychar = ALPHA
  * keychar = ALPHA / DIGIT / HYPHEN
+ * </pre>
  *
  * We additionally add UNDERSCORE because some servers allow them.
  *
- */    
+ * @return The description
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
+ */
 descr returns [String descr]
     {
         matchedProduction( "descr()" );
@@ -552,12 +610,17 @@ descr returns [String descr]
 /**
  * RFC 4512 Section 1.4
  *
+ * <pre>
  * numericoid = number 1*( DOT number )
  * number  = DIGIT / ( LDIGIT 1*DIGIT )
  * DIGIT   = %x30 / LDIGIT       ; "0"-"9"
  * LDIGIT  = %x31-39             ; "1"-"9"
+ * </pre>
  *
- */   
+ * @return The numeric OID
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
+ */
 numericoid returns [String numericoid = ""]
     {
         matchedProduction( "numericoid()" );
@@ -569,15 +632,23 @@ numericoid returns [String numericoid = ""]
 
 /**
  * RFC 4514, Section 3
+ * <pre>
  * attributeValue = string / hexstring
+ * </pre>
  *
  * RFC 2253, Section 3
+ * <pre>
  * attributeValue = string
  * string     = *( stringchar / pair )
  *              / "#" hexstring
  *              / QUOTATION *( quotechar / pair ) QUOTATION ; only from v2
  *
  * We still accept both forms, which means we can have a value surrounded by '"'
+ * </pre>
+ *
+ * @param value The value to update
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
  */
 attributeValue [UpAndNormValue value] 
     {
@@ -597,9 +668,14 @@ attributeValue [UpAndNormValue value]
 
 /**
  * RFC 2253, Section 3
+ * <pre>
  *              / QUOTATION *( quotechar / pair ) QUOTATION ; only from v2
  * quotechar     = &lt;any character except "\" or QUOTATION &gt;
+ * </pre>
  *
+ * @param value The value to update
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
  */
 quotestring [UpAndNormValue value] 
     {
@@ -627,12 +703,17 @@ quotestring [UpAndNormValue value]
 /**
  * RFC 4514 Section 3
  *
+ * <pre>
  * hexstring = SHARP 1*hexpair
  *
  * If in &lt;hexstring&gt; form, a BER representation can be obtained from
  * converting each &lt;hexpair&gt; of the &lt;hexstring&gt; to the octet indicated
  * by the &lt;hexpair&gt;.
+ * </pre>
  *
+ * @param value The value to update
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
  */ 
 hexstring [UpAndNormValue value]
     {
@@ -652,6 +733,7 @@ hexstring [UpAndNormValue value]
 /**
  * RFC 4514 Section 3
  *
+ * <pre>
  * ; The following characters are to be escaped when they appear
  * ; in the value to be encoded: ESC, one of &lt;escaped&gt;, &lt;leading&gt;
  * ; SHARP or SPACE, trailing SPACE, and NULL.
@@ -659,6 +741,11 @@ hexstring [UpAndNormValue value]
  * leadchar = LUTF1 | UTFMB
  * stringchar = SUTF1 / UTFMB
  * trailchar = TUTF1 / UTFMB
+ * </pre>
+ *
+ * @param value The value to update
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
  */ 
 string [UpAndNormValue value]
     {
@@ -675,6 +762,7 @@ string [UpAndNormValue value]
 
 /**
  * RFC 4514, Section 3:
+ * <pre>
  * LUTF1 = %x01-1F / %x21 / %x24-2A / %x2D-3A /
  *    %x3D / %x3F-5B / %x5D-7F
  *
@@ -685,6 +773,11 @@ string [UpAndNormValue value]
  *   UNDERSCORE (0x5F)
  *   DIGIT (0x30-0x39)
  *   ALPHA (0x41-0x5A and 0x61-0x7A)
+ * </pre>
+ *
+ * @param value The value to update
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
  */
 lutf1 [UpAndNormValue value]
     {
@@ -744,6 +837,7 @@ lutf1 [UpAndNormValue value]
 
 /**
  * RFC 4514, Section 3:
+ * <pre>
  * SUTF1 = %x01-21 / %x23-2A / %x2D-3A /
  *    %x3D / %x3F-5B / %x5D-7F
  *
@@ -756,6 +850,11 @@ lutf1 [UpAndNormValue value]
  *   ALPHA (0x41-0x5A and 0x61-0x7A)
  *   SHARP (0x23)
  *   SPACE (0x20)
+ * </pre>
+ *
+ * @param value The value to update
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
  */
 sutf1 [UpAndNormValue value]
     {
@@ -835,7 +934,13 @@ sutf1 [UpAndNormValue value]
     }
     ;
 
-
+/**
+ * Process a UTFMB char
+ *
+ * @param value The value to update
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
+ */
 utfmb [UpAndNormValue value]
     {
         matchedProduction( "utfmb()" );
@@ -852,6 +957,7 @@ utfmb [UpAndNormValue value]
 
 /**
  * RFC 4514, Section 3
+ * <pre>
  * pair = ESC ( ESC / special / hexpair )
  * special = escaped / SPACE / SHARP / EQUALS
  * escaped = DQUOTE / PLUS / COMMA / SEMI / LANGLE / RANGLE
@@ -863,16 +969,24 @@ utfmb [UpAndNormValue value]
  *   replace &lt;ESC&gt;&lt;ESC&gt; with &lt;ESC&gt;;
  *   replace &lt;ESC&gt;&lt;special&gt; with &lt;special&gt;;
  *   replace &lt;ESC&gt;&lt;hexpair&gt; with the octet indicated by the &lt;hexpair&gt;.
+ * </pre>
  * 
  * RFC 2253, Section 3
+ * <pre>
  * pair       = "\" ( special / "\" / QUOTATION / hexpair )
  * special    = "," / "=" / "+" / "&lt;" /  "&gt;" / "#" / ";"
+ * </pre>
  * 
  * RFC 1779, Section 2.3
+ * <pre>
  * &lt;pair&gt; ::= "\" ( &lt;special&gt; | "\" | '"')
  * &lt;special&gt; ::= "," | "=" | &lt;CR&gt; | "+" | "&lt;" |  "&gt;"
  *           | "#" | ";"
+ * </pre>
  * 
+ * @param value The value to update
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
  */ 
 pair [UpAndNormValue value]
     {
@@ -919,13 +1033,18 @@ pair [UpAndNormValue value]
 /**
  * RFC 4514 Section 3
  * 
+ * <pre>
  * special = escaped / SPACE / SHARP / EQUALS
  * escaped = DQUOTE / PLUS / COMMA / SEMI / LANGLE / RANGLE
+ * </pre>
  *
+ * @return The special char
+ * @throws RecognitionException If the token is invalid
+ * @throws TokenStreamException When we weren't able to fetch a token
  */
 special returns [char special]
     {
-        matchedProduction( "special()" );
+        matchedProduction( "()" );
     }
     :
     (
diff --git a/ldap/model/src/main/antlr/subtree-specification.g b/ldap/model/src/main/antlr/subtree-specification.g
index ce9be20..fe8d001 100644
--- a/ldap/model/src/main/antlr/subtree-specification.g
+++ b/ldap/model/src/main/antlr/subtree-specification.g
@@ -105,7 +105,9 @@ options
     
 
     /**
-     * Does nothing.
+     * Initialize the parser
+     *
+     * @param schemaManager the SchemaManager instance
      */
     public void init( SchemaManager schemaManager )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/entry/ModificationOperation.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/entry/ModificationOperation.java
index 0c28d32..bbb1af7 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/entry/ModificationOperation.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/entry/ModificationOperation.java
@@ -44,6 +44,8 @@ public enum ModificationOperation
 
     /**
      * Creates a new instance of ModificationOperation.
+     * 
+     * @param value The value
      */
     ModificationOperation( int value )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/ldif/LdifRevertor.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/ldif/LdifRevertor.java
index 3b0b3a1..64c654a 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/ldif/LdifRevertor.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/ldif/LdifRevertor.java
@@ -302,6 +302,14 @@ public final class LdifRevertor
 
     /**
      * A small helper class to compute the simple revert.
+     * 
+     * @param entry The entry to revert
+     * @param newDn The new Dn
+     * @param newSuperior The new superior, if it has changed (null otherwise)
+     * @param oldRdn The old Rdn
+     * @param newRdn The new RDN if the RDN has changed
+     * @return The reverted entry
+     * @throws LdapInvalidDnException If the Dn is invalid
      */
     private static LdifEntry revertEntry( Entry entry, Dn newDn, Dn newSuperior, Rdn oldRdn, Rdn newRdn )
         throws LdapInvalidDnException
@@ -345,6 +353,12 @@ public final class LdifRevertor
 
     /**
      * A helper method to generate the modified attribute after a rename.
+     * 
+     * @param parentDn The parent Dn
+     * @param entry The entry to revert
+     * @param oldRdn The old Rdn
+     * @param newRdn The new Rdn
+     * @return The modified entry
      */
     private static LdifEntry generateModify( Dn parentDn, Entry entry, Rdn oldRdn, Rdn newRdn )
     {
@@ -376,7 +390,15 @@ public final class LdifRevertor
 
 
     /**
-     * A helper method which generates a reverted entry
+     * A helper method which generates a reverted entry for a MODDN operation
+     * 
+     * @param newSuperior The new superior, if it has changed (null otherwise)
+     * @param newRdn The new RDN if the RDN has changed
+     * @param newDn The new Dn
+     * @param oldRdn The old Rdn
+     * @param deleteOldRdn If the old Rdn attributes must be deleted or not
+     * @return The reverted entry
+     * @throws LdapInvalidDnException If the DN is invalid
      */
     private static LdifEntry generateReverted( Dn newSuperior, Rdn newRdn, Dn newDn, Rdn oldRdn, boolean deleteOldRdn )
         throws LdapInvalidDnException
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/message/AliasDerefMode.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/message/AliasDerefMode.java
index 2b32056..1fec7e1 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/message/AliasDerefMode.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/message/AliasDerefMode.java
@@ -60,6 +60,7 @@ public enum AliasDerefMode
      * public static constants in this class.
      * 
      * @param value the integer value of the enumeration.
+     * @param jndiValue the JNDI value
      */
     AliasDerefMode( int value, String jndiValue )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/message/extended/NoticeOfDisconnect.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/message/extended/NoticeOfDisconnect.java
index 603db95..96afb84 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/message/extended/NoticeOfDisconnect.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/message/extended/NoticeOfDisconnect.java
@@ -120,6 +120,8 @@ public final class NoticeOfDisconnect extends ExtendedResponseImpl
 
     /**
      * Creates a new instance of NoticeOfDisconnect.
+     * 
+     * @param rcode The result code
      */
     private NoticeOfDisconnect( ResultCodeEnum rcode )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/ComplexDnParser.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/ComplexDnParser.java
index 428d339..8cf9c43 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/ComplexDnParser.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/ComplexDnParser.java
@@ -39,8 +39,10 @@ import org.apache.directory.api.ldap.model.schema.SchemaManager;
     /**
      * Parses an Dn.
      * 
+     * @param schemaManager The SchemaManager
      * @param name the string representation of the distinguished name
      * @param rdns the (empty) list where parsed RDNs are put to
+     * @return The normalized Dn
      * 
      * @throws LdapInvalidDnException the invalid name exception
      */
@@ -62,6 +64,7 @@ import org.apache.directory.api.ldap.model.schema.SchemaManager;
     /**
      * Parses an Rdn.
      * 
+     * @param schemaManager The SchemaManager
      * @param name the string representation of the relative distinguished name
      * @param rdn the (empty) Rdn where parsed ATAVs are put into
      * 
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/Dn.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/Dn.java
index a554b0e..2616842 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/Dn.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/Dn.java
@@ -1028,6 +1028,8 @@ public class Dn implements Iterable<Rdn>, Externalizable
 
     /**
      * Create a copy of the current Dn
+     * 
+     * @return The copied Dn
      */
     private Dn copy()
     {
@@ -1196,8 +1198,10 @@ public class Dn implements Iterable<Rdn>, Externalizable
     /**
      * Parse a Dn.
      *
+     * @param schemaManager The SchemaManager
      * @param name The Dn to be parsed
      * @param rdns The list that will contain the RDNs
+     * @return The nromalized Dn
      * @throws LdapInvalidDnException If the Dn is invalid
      */
     private static String parseInternal( SchemaManager schemaManager, String name, List<Rdn> rdns ) throws LdapInvalidDnException
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/FastDnParser.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/FastDnParser.java
index 35679bc..5e94a6d 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/FastDnParser.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/FastDnParser.java
@@ -61,9 +61,10 @@ import org.apache.directory.api.util.Strings;
     /**
      * Parses a Dn from a String
      *
+     * @param schemaManager The SchemaManager
      * @param name The Dn to parse
      * @return A valid Dn
-     * @throws org.apache.directory.api.ldap.model.exception.LdapException If the Dn was invalid
+     * @throws LdapException If the Dn was invalid
      */
     /* No protection*/static Dn parse( SchemaManager schemaManager, String name ) throws LdapException
     {
@@ -77,6 +78,7 @@ import org.apache.directory.api.util.Strings;
     /**
      * Parses the given name string and fills the given Dn object.
      * 
+     * @param schemaManager The SchemaManager
      * @param name the name to parse
      * @param dn the Dn to fill
      * 
@@ -141,6 +143,7 @@ import org.apache.directory.api.util.Strings;
     /**
      * Parses the given name string and fills the given Rdn object.
      * 
+     * @param schemaManager The SchemaManager
      * @param name the name to parse
      * @param rdn the Rdn to fill
      * 
@@ -237,7 +240,7 @@ import org.apache.directory.api.util.Strings;
      * 
      * @param name the name
      * @param pos the pos
-     * @throws LdapInvalidDnException 
+     * @throws LdapInvalidDnException If some invalid chars are found 
      */
     private static void matchSpaces( char[] name, Position pos ) throws LdapInvalidDnException
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/Rdn.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/Rdn.java
index 64fc850..342ee76 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/Rdn.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/name/Rdn.java
@@ -525,6 +525,10 @@ public class Rdn implements Cloneable, Externalizable, Iterable<Ava>, Comparable
     
     /**
      * Add an AVA in a List of Ava, at the right place (ordered)
+     * 
+     * @param avaList The list of Ava
+     * @param newAva The Ava to add
+     * @return The list of Ava with the new Ava at the right position
      */
     private List<Ava> addOrdered( List<Ava> avaList, Ava newAva )
     {
@@ -683,7 +687,9 @@ public class Rdn implements Cloneable, Externalizable, Iterable<Ava>, Comparable
     /**
      * Add an Ava to the current schema aware Rdn
      *
+     * @param schemaManager The SchemaManager
      * @param addedAva The added Ava
+     * @throws LdapInvalidDnException If the Ava is invalid
      */
     // WARNING : The protection level is left unspecified intentionally.
     // We need this method to be visible from the DnParser class, but not
@@ -1692,6 +1698,7 @@ public class Rdn implements Cloneable, Externalizable, Iterable<Ava>, Comparable
      * &lt;spaces&gt; &lt;attributeValue&gt; &lt;nameComponents&gt;
      * </p>
      *
+     * @param schemaManager The SchemaManager
      * @param dn The String to parse
      * @param rdn The Rdn to fill. Beware that if the Rdn is not empty, the new
      *            AttributeTypeAndValue will be added.
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/password/PasswordUtil.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/password/PasswordUtil.java
index 4eec604..34bc38d 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/password/PasswordUtil.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/password/PasswordUtil.java
@@ -348,6 +348,10 @@ public final class PasswordUtil
      *  [1] https://en.wikipedia.org/wiki/Timing_attack
      *  [2] http://rdist.root.org/2009/05/28/timing-attack-in-google-keyczar-library/
      *  [3] https://cryptocoding.net/index.php/Coding_rules
+     *  
+     * @param provided The provided password
+     * @param stored The stored password
+     * @return <tt>true</tt> if the compared passwords are equal
      */
     private static boolean compareBytes( byte[] provided, byte[] stored )
     {
@@ -553,6 +557,12 @@ public final class PasswordUtil
 
     /**
      * Compute the credentials
+     * 
+     * @param credentials the credentials
+     * @param algoLength The algorithm length
+     * @param hashLen The hash length
+     * @param algorithm the algorithm to use
+     * @return The split password string, containing the credentials, the salt and the password
      */
     private static PasswordDetails getCredentials( byte[] credentials, int algoLength, int hashLen,
         LdapSecurityConstants algorithm )
@@ -624,6 +634,7 @@ public final class PasswordUtil
      * 
      * Note: this has been implemented to generate hashes compatible with what JIRA generates.
      *       See the <a href="http://pythonhosted.org/passlib/lib/passlib.hash.atlassian_pbkdf2_sha1.html">JIRA's passlib</a>
+     *       
      * @param credentials the credentials
      * @param algorithm the algorithm to use
      * @param salt the optional salt
@@ -649,6 +660,11 @@ public final class PasswordUtil
     /**
      * Gets the credentials from a PKCS5S2 hash.
      * The salt for PKCS5S2 hash is prepended to the password
+     * 
+     * @param credentials The password
+     * @param algoLength The length of the algorithm part
+     * @param algorithm The algorithm in use
+     * @return The split credentials, containing the algorithm, the salt and the password 
      */
     private static PasswordDetails getPbkdf2Credentials( byte[] credentials, int algoLength, LdapSecurityConstants algorithm )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/DescriptionUtils.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/DescriptionUtils.java
index 1ff4967..0c6b4ea 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/DescriptionUtils.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/DescriptionUtils.java
@@ -174,6 +174,9 @@ public final class DescriptionUtils
 
     /**
      * Generate the description for Comparators, Normalizers and SyntaxCheckers.
+     * 
+     * @param schemaObject The SchemaObject to process
+     * @return the found description
      */
     private static String getLoadableDescription( LoadableSchemaObject schemaObject )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/MatchingRuleTypeEnum.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/MatchingRuleTypeEnum.java
index ef55973..e9b2a13 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/MatchingRuleTypeEnum.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/MatchingRuleTypeEnum.java
@@ -89,6 +89,8 @@ public enum MatchingRuleTypeEnum
     
     /**
      * Create an instance of MatchingRuleTypeEnum
+     * 
+     * @param oid The MatchingRule OID
      */
     MatchingRuleTypeEnum( String oid )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/PrepareString.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/PrepareString.java
index da355b7..b85532c 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/PrepareString.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/PrepareString.java
@@ -4218,6 +4218,9 @@ public final class PrepareString
     
     /**
      * Map for Ascii String, case insensitive
+     * 
+     * @param unicode The string to map
+     * @return The lower cased string
      */
     private static String mapIgnoreCaseAscii( String unicode )
     {
@@ -4399,6 +4402,9 @@ public final class PrepareString
     
     /**
      * Map for Ascii String, case sensitive
+     * 
+     * @param unicode The string to re-map
+     * @return The mapped string
      */
     private static String mapCaseSensitiveAscii( String unicode )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SchemaErrorHandler.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SchemaErrorHandler.java
index 8fd82b1..55fcc25 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SchemaErrorHandler.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SchemaErrorHandler.java
@@ -50,11 +50,15 @@ public interface SchemaErrorHandler
      * Returns true if the implementation handled at least one error.
      * This method is used for checks whether the schema processing should proceed or
      * stop, e.g. in cases when we want to stop processing on errors.
+     * 
+     * @return <tt>true</tt> if at least one error was met
      */
     boolean wasError();
     
     /**
      * Returns list of handled errors.
+     * 
+     * @return The list of found errors
      */
     List<Throwable> getErrors();
     
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SchemaObjectRenderer.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SchemaObjectRenderer.java
index 91fcf9d..063f0e0 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SchemaObjectRenderer.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SchemaObjectRenderer.java
@@ -657,6 +657,8 @@ public final class SchemaObjectRenderer
      * qdescrlist ::= [ qdescr ( SP qdescr )* ]
      * qdescr     ::= SQUOTE descr SQUOTE
      * </pre>
+     * 
+     * @param buf The buffer that will contain the result.
      * @param qdescrs the quoted description strings to render
      * @return the string buffer the qdescrs are rendered into
      */
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SchemaObjectType.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SchemaObjectType.java
index 4482fab..e6ab298 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SchemaObjectType.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SchemaObjectType.java
@@ -70,6 +70,8 @@ public enum SchemaObjectType
 
     /**
      * A private constructor to associated a number to the type
+     * 
+     * @param value the value
      */
     SchemaObjectType( int value )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SyntaxChecker.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SyntaxChecker.java
index 6eeaccb..d9d0897 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SyntaxChecker.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/SyntaxChecker.java
@@ -48,6 +48,8 @@ public abstract class SyntaxChecker extends LoadableSchemaObject
         
         /**
          * The Builder constructor
+         * 
+         * @param oid The SyntaxChecker OID
          */
         protected SCBuilder( String oid )
         {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/comparators/IntegerComparator.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/comparators/IntegerComparator.java
index 47caa6a..e721164 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/comparators/IntegerComparator.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/comparators/IntegerComparator.java
@@ -74,43 +74,29 @@ public class IntegerComparator extends LdapComparator<Object> implements Seriali
         }
         else
         {
-            return compare( ( Long ) v1, ( Long ) v2 );
+            if ( v2 instanceof String )
+            {
+                return compare( ( String ) v1, ( String ) v2 );
+            }
+            else if ( v2 instanceof Value )
+            {
+                return compare( null, ( ( Value ) v2 ).getValue() );
+            }
+            else
+            {
+                return compare( null, v2 );
+            }
         }
     }
 
 
     /**
      * Implementation of the Compare method
-     */
-    private int compare( Long backendValue, Long assertValue )
-    {
-        if ( LOG.isDebugEnabled() )
-        {
-            LOG.debug( I18n.msg( I18n.MSG_13746_COMPARING_INTEGER, backendValue, assertValue ) );
-        }
-
-        // First, shortcut the process by comparing
-        // references. If they are equals, then o1 and o2
-        // reference the same object
-        if ( backendValue == assertValue )
-        {
-            return 0;
-        }
-
-        // Then, deal with one of o1 or o2 being null
-        // Both can't be null, because then they would
-        // have been caught by the previous test
-        if ( ( backendValue == null ) || ( assertValue == null ) )
-        {
-            return backendValue == null ? -1 : 1;
-        }
-
-        return backendValue.compareTo( assertValue );
-    }
-
-
-    /**
-     * Implementation of the Compare method
+     * 
+     * @param backendValue The stored value
+     * @param assertValue The provided value
+     * @return <tt>0</tt> if the values are equal, <tt>-1</tt> if the provided value is below
+     * the stored value, <tt>+1</tt> otherwise
      */
     private int compare( String backendValue, String assertValue )
     {
@@ -155,10 +141,22 @@ public class IntegerComparator extends LdapComparator<Object> implements Seriali
         {
             throw new IllegalArgumentException( I18n.err( I18n.ERR_13724_INVALID_VALUE, assertValue ), le );
         }
-
-        BigInteger b1 = new BigInteger( backendValue );
-        BigInteger b2 = new BigInteger( assertValue );
-
-        return b1.compareTo( b2 );
+        
+        try
+        {
+            // First try with longs
+            Long l1 = Long.valueOf( backendValue );
+            Long l2 = Long.valueOf( assertValue );
+            
+            return l1.compareTo( l2 );
+        }
+        catch ( NumberFormatException nfe )
+        {
+            // Ok, try with BigIntegers
+            BigInteger b1 = new BigInteger( backendValue );
+            BigInteger b2 = new BigInteger( assertValue );
+    
+            return b1.compareTo( b2 );
+        }
     }
 }
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/comparators/ObjectIdentifierFirstComponentComparator.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/comparators/ObjectIdentifierFirstComponentComparator.java
index 06b55c2..41f2891 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/comparators/ObjectIdentifierFirstComponentComparator.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/comparators/ObjectIdentifierFirstComponentComparator.java
@@ -57,6 +57,9 @@ public class ObjectIdentifierFirstComponentComparator extends LdapComparator<Str
 
     /**
      * Get the OID from the SchemaObject description
+     * 
+     * @param s The string cntaining the OID
+     * @return The found OID
      */
     private String getNumericOid( String s )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/comparators/TelephoneNumberComparator.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/comparators/TelephoneNumberComparator.java
index e9376de..8779b99 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/comparators/TelephoneNumberComparator.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/comparators/TelephoneNumberComparator.java
@@ -57,6 +57,9 @@ public class TelephoneNumberComparator extends LdapComparator<String>
 
     /**
      * Remove all spaces and '-' from the telephone number
+     * 
+     * @param telephoneNumber The telephoneNumber to strip
+     * @return teh stripped telephoneNumber
      */
     private String strip( String telephoneNumber )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/parsers/OpenLdapSchemaParser.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/parsers/OpenLdapSchemaParser.java
index c010302..dad476f 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/parsers/OpenLdapSchemaParser.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/parsers/OpenLdapSchemaParser.java
@@ -603,6 +603,12 @@ public class OpenLdapSchemaParser
     }
 
 
+    /**
+     * Return a complete OID from a macro followed by an OID.
+     * 
+     * @param oid The OID to find
+     * @return The extended OID
+     */
     private String getResolveOid( String oid )
     {
         if ( oid != null && oid.indexOf( COLON ) != -1 )
@@ -622,6 +628,12 @@ public class OpenLdapSchemaParser
     }
 
 
+    /**
+     * Find the proper OID from a OID which may contain a macro
+     * 
+     * @param macro The element to resolve
+     * @throws ParseException If teh OID is invalid
+     */
     private void resolveObjectIdentifierMacro( OpenLdapObjectIdentifierMacro macro ) throws ParseException
     {
         String rawOidOrNameSuffix = macro.getRawOidOrNameSuffix();
@@ -722,6 +734,14 @@ public class OpenLdapSchemaParser
     }
     
     
+    /**
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param mandatory If the spaces are mandatory
+     * @throws IOException If the stream can't be read
+     * @throws LdapSchemaException If the schema is wrong
+     */
     private static void skipWhites( Reader reader, PosSchema pos, boolean mandatory ) throws IOException, LdapSchemaException
     {
         boolean hasSpace = false;
@@ -788,6 +808,10 @@ public class OpenLdapSchemaParser
     }
     
     
+    /**
+     * @param pos The position in the Schema
+     * @return <tt>true</tt> if this is a comment
+     */
     private static boolean isComment( PosSchema pos )
     {
         if ( isEmpty( pos ) )
@@ -799,12 +823,21 @@ public class OpenLdapSchemaParser
     }
     
     
+    /**
+     * @param pos The position in the Schema
+     * @return <tt>true</tt> of the line is empty
+     */
     private static boolean isEmpty( PosSchema pos )
     {
         return ( pos.line == null ) || ( pos.start >= pos.line.length() );
     }
     
     
+    /**
+     * @param pos The position in the Schema
+     * @param text The text to find at the beginning of the line
+     * @return <tt>true</tt> if teh line starts with the given text
+     */
     private static boolean startsWith( PosSchema pos, String text )
     {
         if ( ( pos.line == null ) || ( pos.line.length() - pos.start < text.length() ) )
@@ -816,12 +849,33 @@ public class OpenLdapSchemaParser
     }
     
     
+    /**
+     * Check if the stream starts with a given char at a given position
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param c The char to check
+     * @return <tt>true</tT> if the stream starts with the given char at the given position
+     * @throws IOException If we can't read the stream
+     * @throws LdapSchemaException If we have no char to read
+     */
     private static boolean startsWith( Reader reader, PosSchema pos, char c ) throws IOException, LdapSchemaException
     {
         return startsWith( reader, pos, c, UN_QUOTED );
     }
     
-    
+
+    /**
+     * Check if the stream at the given position starts with a given char
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param c The char to check
+     * @param quoted <tt>true</tt> if the char is quoted
+     * @return <tt>true</tt> if the stream starts with the given char at the given position
+     * @throws IOException If we can't read the stream
+     * @throws LdapSchemaException If we have no char to read
+     */
     private static boolean startsWith( Reader reader, PosSchema pos, char c, boolean quoted ) throws IOException, LdapSchemaException
     {
         if ( ( pos.line == null ) || ( pos.line.length() - pos.start < 1 ) )
@@ -856,6 +910,11 @@ public class OpenLdapSchemaParser
     }
     
     
+    /**
+     * @param pos The position in the Schema
+     * @param c The char to find at the beginning of the line
+     * @return <tt>true</tt> if the char is found at the beginning of the line
+     */
     private static boolean startsWith( PosSchema pos, char c )
     {
         if ( ( pos.line == null ) || ( pos.line.length() - pos.start < 1 ) )
@@ -867,18 +926,32 @@ public class OpenLdapSchemaParser
     }
 
     
+    /**
+     * @param pos The position in the Schema
+     * @return <tt>true</tt> if the first char is alphabetic
+     */
     private static boolean isAlpha( PosSchema pos )
     {
         return Character.isAlphabetic( pos.line.charAt( pos.start ) );
     }
     
     
+    /**
+     * @param pos The position in the Schema
+     * @return <tt>true</tt> if the first char is a digit
+     */
     private static boolean isDigit( PosSchema pos )
     {
         return Character.isDigit( pos.line.charAt( pos.start ) );
     }
 
     
+    /**
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @throws IOException If the stream can't be read
+     */
     private static void getLine( Reader reader, PosSchema pos ) throws IOException
     {
         pos.line = ( ( BufferedReader ) reader ).readLine();
@@ -892,11 +965,17 @@ public class OpenLdapSchemaParser
     
     
     /**
+     * <pre>
      * numericoid   ::= number ( DOT number )+
      * number       ::= DIGIT | LDIGIT DIGIT+
      * DIGIT        ::= %x30 | LDIGIT       ; "0"-"9"
      * LDIGIT       ::= %x31-39             ; "1"-"9"
      * DOT          ::= %x2E                ; period (".")
+     * </pre>
+     * 
+     * @param pos The position in the Schema
+     * @return The numeric OID
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static String getNumericOid( PosSchema pos ) throws LdapSchemaException
     {
@@ -964,11 +1043,17 @@ public class OpenLdapSchemaParser
     
     
     /**
+     * <pre>
      * partialNumericoid   ::= number ( DOT number )*
      * number              ::= DIGIT | LDIGIT DIGIT+
      * DIGIT               ::= %x30 | LDIGIT       ; "0"-"9"
      * LDIGIT              ::= %x31-39             ; "1"-"9"
      * DOT                 ::= %x2E                ; period (".")
+     * </pre>
+     * 
+     * @param pos The position in the Schema
+     * @return The found OID
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static String getPartialNumericOid( PosSchema pos ) throws LdapSchemaException
     {
@@ -1047,6 +1132,11 @@ public class OpenLdapSchemaParser
      * SEMI_COLON   ::= %x3B                ; semi-colon(";")
      * SHARP        ::= %x23                ; octothorpe (or sharp sign) ("#")
      * </pre>
+     * 
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return The found OID
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static String getOidAndMacroRelaxed( PosSchema pos, 
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws LdapSchemaException
@@ -1123,6 +1213,10 @@ public class OpenLdapSchemaParser
      * DOT          ::= %x2E                ; period (".")
      * HYPHEN       ::= %x2D                ; hyphen ("-")
      * </pre>
+     * 
+     * @param pos The position in the Schema
+     * @return The found OID
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static String getOidStrict( PosSchema pos ) throws LdapSchemaException
     {
@@ -1172,6 +1266,11 @@ public class OpenLdapSchemaParser
      * SEMI_COLON   ::= %x3B                ; semi-colon(";")
      * SHARP        ::= %x23                ; octothorpe (or sharp sign) ("#")
      * </pre>
+     * 
+     * @param pos The position in the Schema
+     * @param hadQuote If we have had a quote
+     * @return the found OID
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static String getOidRelaxed( PosSchema pos, boolean hadQuote ) throws LdapSchemaException
     {
@@ -1269,6 +1368,10 @@ public class OpenLdapSchemaParser
      * DOT          ::= %x2E                ; period (".")
      * HYPHEN       ::= %x2D                ; hyphen ("-")
      * </pre>
+     * 
+     * @param pos The position in the Schema
+     * @return The descr
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static String getDescrStrict( PosSchema pos ) throws LdapSchemaException
     {
@@ -1335,6 +1438,10 @@ public class OpenLdapSchemaParser
      * SEMI_COLON   ::= %x3B                ; semi-colon(";")
      * SHARP        ::= %x23                ; octothorpe (or sharp sign) ("#")
      * </pre>
+     * 
+     * @param pos The position in the Schema
+     * @return The descr
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static String getDescrRelaxed( PosSchema pos ) throws LdapSchemaException
     {
@@ -1383,6 +1490,12 @@ public class OpenLdapSchemaParser
     }
     
     
+    /**
+     * 
+     * @param pos The position in the Schema
+     * @return The found macro, if any
+     * @throws LdapSchemaException If the schema is wrong
+     */
     private String getMacro( PosSchema pos ) throws LdapSchemaException
     {
         if ( isQuirksModeEnabled )
@@ -1491,7 +1604,12 @@ public class OpenLdapSchemaParser
      * keystring ::= keychar+
      * keychar ::= ALPHA | DIGIT | HYPHEN | UNDERSCORE | SEMI_COLON | DOT | COLON | SHARP 
      * </pre>
-     * @throws IOException 
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @return The QDescr
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static String getQDescrStrict( Reader reader, PosSchema pos ) throws LdapSchemaException, IOException
     {
@@ -1581,7 +1699,12 @@ public class OpenLdapSchemaParser
      * keystring ::= keychar+
      * keychar ::= ALPHA | DIGIT | HYPHEN | UNDERSCORE | SEMI_COLON | DOT | COLON | SHARP 
      * </pre>
-     * @throws IOException 
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @return the QDescr
+     * @throws IOException If the stream can't be read
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static String getQDescrRelaxed( Reader reader, PosSchema pos ) throws LdapSchemaException, IOException
     {
@@ -1655,6 +1778,12 @@ public class OpenLdapSchemaParser
      * UTF4     ::= %xF0 %x90-BF UTF0 UTF0 | %xF1-F3 UTF0 UTF0 UTF0 | %xF4 %x80-8F UTF0 UTF0
      * ESC      ::= %x5C                            ; backslash ("\")
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @return The QDString
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static String getQDString( Reader reader, PosSchema pos ) throws LdapSchemaException, IOException
     {
@@ -1729,6 +1858,7 @@ public class OpenLdapSchemaParser
 
 
     /**
+     * <pre>
      * qdescrs ::= qdescr | LPAREN WSP qdescrlist WSP RPAREN
      * qdescrlist ::= [ qdescr *( SP qdescr ) ]
      * qdescr ::== SQUOTE descr SQUOTE
@@ -1736,10 +1866,17 @@ public class OpenLdapSchemaParser
      * keystring ::= leadkeychar *keychar
      * leadkeychar ::= ALPHA
      * keychar ::= ALPHA / DIGIT / HYPHEN
-     * @throws LdapSchemaException 
-     * @throws IOException 
+     * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param relaxed If the schema is to be processed in relaxed mode
+     * @return The list of QDescr
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
-    private static List<String> getQDescrs( Reader reader, PosSchema pos, boolean relaxed ) throws LdapSchemaException, IOException
+    private static List<String> getQDescrs( Reader reader, PosSchema pos, boolean relaxed ) 
+            throws LdapSchemaException, IOException
     {
         List<String> qdescrs = new ArrayList<>();
         
@@ -1815,8 +1952,12 @@ public class OpenLdapSchemaParser
      * qdstring     ::= SQUOTE dstring SQUOTE
      * dstring      ::= 1*( QS / QQ / QUTF8 )   ; escaped UTF-8 string
      * </pre>
-     * @throws LdapSchemaException 
-     * @throws IOException 
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @return The list of QDString
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static List<String> getQDStrings( Reader reader, PosSchema pos ) 
         throws LdapSchemaException, IOException
@@ -1866,6 +2007,12 @@ public class OpenLdapSchemaParser
      * oids     ::= oid | ( LPAREN WSP oidlist WSP RPAREN )
      * oidlist  ::= oid *( WSP DOLLAR WSP oid )
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @return The list of OIDs
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static List<String> getOidsStrict( Reader reader, PosSchema pos ) throws LdapSchemaException, IOException
     {
@@ -1931,6 +2078,12 @@ public class OpenLdapSchemaParser
      * oids     ::= oid | ( LPAREN WSP oidlist WSP RPAREN )
      * oidlist  ::= oid *( WSP DOLLAR WSP oid )
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @return The list of OIDs
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static List<String> getOidsRelaxed( Reader reader, PosSchema pos ) throws LdapSchemaException, IOException
     {
@@ -1992,7 +2145,13 @@ public class OpenLdapSchemaParser
 
     
     /**
+     * <pre>
      * noidlen = oidStrict [ LCURLY len RCURLY ]
+     * </pre>
+     *  
+     * @param attributeType The AttributeType
+     * @param pos The position in the Schema
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static void getNoidLenStrict( MutableAttributeType attributeType, PosSchema pos ) throws LdapSchemaException
     {
@@ -2048,7 +2207,13 @@ public class OpenLdapSchemaParser
 
     
     /**
+     * <pre>
      * noidlen = oidRelaxed [ LCURLY len RCURLY ]
+     * </pre>
+     * 
+     * @param attributeType The AttributeType
+     * @param pos The position in the Schema
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static void getNoidLenRelaxed( MutableAttributeType attributeType, PosSchema pos ) throws LdapSchemaException
     {
@@ -2144,6 +2309,10 @@ public class OpenLdapSchemaParser
      * DIGIT  ::= [0-9]
      * LDIGIT ::= [1-9]
      * </pre>
+     * 
+     * @param pos The position in the Schema
+     * @return The RuleID
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static int getRuleId( PosSchema pos ) throws LdapSchemaException
     {
@@ -2172,6 +2341,12 @@ public class OpenLdapSchemaParser
      * ruleids      ::= ruleid | ( LPAREN WSP ruleidlist WSP RPAREN )
      * ruleidlist   ::= ruleid ( SP ruleid )*
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @return The list of RuleIDs
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static List<Integer> getRuleIds( Reader reader, PosSchema pos ) throws LdapSchemaException, IOException
     {
@@ -2232,6 +2407,12 @@ public class OpenLdapSchemaParser
     }
     
     
+    /**
+     * 
+     * @param pos The position in the Schema
+     * @return The USAGE
+     * @throws LdapSchemaException If the schema is wrong
+     */
     private static UsageEnum getUsageStrict( PosSchema pos ) throws LdapSchemaException
     {
         if ( isEmpty( pos ) )
@@ -2272,6 +2453,12 @@ public class OpenLdapSchemaParser
     }
     
     
+    /**
+     * 
+     * @param pos The position in the Schema
+     * @return The USAGE
+     * @throws LdapSchemaException If the schema is wrong
+     */
     private static UsageEnum getUsageRelaxed( PosSchema pos ) throws LdapSchemaException
     {
         if ( isEmpty( pos ) )
@@ -2384,8 +2571,12 @@ public class OpenLdapSchemaParser
      * qdstring     ::= SQUOTE dstring SQUOTE
      * dstring      ::= 1*( QS / QQ / QUTF8 )   ; escaped UTF-8 string
      * </pre>
-     * @throws IOException 
-     * @throws LdapSchemaException 
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param schemaObject The SchemaObject
+     * @throws IOException If the stream can't be read
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static void processExtension( Reader reader, PosSchema pos, SchemaObject schemaObject ) 
         throws LdapSchemaException, IOException
@@ -2412,6 +2603,10 @@ public class OpenLdapSchemaParser
      * <pre>
      * xstring      ::= "X" HYPHEN ( ALPHA | HYPHEN | USCORE )+
      * </pre>
+     * 
+     * @param pos The position in the Schema
+     * @return the X-String
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static String getXString( PosSchema pos ) throws LdapSchemaException
     {
@@ -2443,6 +2638,10 @@ public class OpenLdapSchemaParser
      * FQCN ::= FQCN_IDENTIFIER ( '.' FQCN_IDENTIFIER )*
      * FQCN_IDENTIFIER ::= ( JavaLetter ( JavaLetterOrDigit )*
      * </pre>
+     * 
+     * @param pos The position in the Schema
+     * @return The FQCN
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static String getFqcn( PosSchema pos ) throws LdapSchemaException
     {
@@ -2514,6 +2713,9 @@ public class OpenLdapSchemaParser
      * <pre>
      * byteCode ::= ( [a-z] | [A-Z] | [0-9] | '+' | '/' | '=' )*
      * </pre>
+     * 
+     * @param pos The position in the Schema
+     * @return The ByteCode
      */
     private static String getByteCode( PosSchema pos )
     {
@@ -2540,6 +2742,14 @@ public class OpenLdapSchemaParser
     }
     
     
+    /**
+     * 
+     * @param elementsSeen The elements that have been processed already
+     * @param element The current element
+     * @param pos T he position in the Schema
+     * @return The elements we have just processed
+     * @throws LdapSchemaException If the schema is wrong
+     */
     private static int checkElement( int elementsSeen, SchemaObjectElements element, PosSchema pos ) throws LdapSchemaException
     {
         if ( ( elementsSeen & element.getValue() ) != 0 )
@@ -2646,8 +2856,13 @@ public class OpenLdapSchemaParser
      * extensions = *( SP xstring SP qdstrings )
      * xstring = "X" HYPHEN 1*( ALPHA / HYPHEN / USCORE ) 
      * </pre>
-     * @throws IOException 
-     * @throws LdapSchemaException 
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of AttributeType
+     * @throws IOException If the stream can't be read
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static AttributeType parseAttributeTypeStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
@@ -2888,8 +3103,13 @@ public class OpenLdapSchemaParser
      * extensions = *( SP xstring SP qdstrings )
      * xstring = "X" HYPHEN 1*( ALPHA / HYPHEN / USCORE ) 
      * </pre>
-     * @throws IOException 
-     * @throws LdapSchemaException 
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of AttributeType
+     * @throws IOException If the stream can't be read
+     * @throws LdapSchemaException If the schema is wrong
      */
     private static AttributeType parseAttributeTypeRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
@@ -3136,6 +3356,13 @@ public class OpenLdapSchemaParser
      *    [ SP "NOT" SP oids ]       ; attribute types
      *    extensions WSP RPAREN      ; extensions
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of DitContentRule
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static DitContentRule parseDitContentRuleStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
@@ -3293,6 +3520,13 @@ public class OpenLdapSchemaParser
      *    [ SP "NOT" SP oids ]       ; attribute types
      *    extensions WSP RPAREN      ; extensions
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of DitContentRule
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static DitContentRule parseDitContentRuleRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
@@ -3497,6 +3731,12 @@ public class OpenLdapSchemaParser
      * ruleidlist = ruleid *( SP ruleid )
      * ruleid = number
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @return An instance of DitStructureRule
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static DitStructureRule parseDitStructureRuleStrict( Reader reader, PosSchema pos ) 
         throws IOException, LdapSchemaException
@@ -3634,6 +3874,13 @@ public class OpenLdapSchemaParser
      * ruleidlist = ruleid *( SP ruleid )
      * ruleid = number
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of DitStructureRule
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static DitStructureRule parseDitStructureRuleRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
@@ -3819,6 +4066,13 @@ public class OpenLdapSchemaParser
      * fqcn = fqcnComponent 1*( DOT fqcnComponent )
      * fqcnComponent = ???
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of LdapComparatorDescription
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static LdapComparatorDescription parseLdapComparatorStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
@@ -3949,6 +4203,13 @@ public class OpenLdapSchemaParser
      * fqcn = fqcnComponent 1*( DOT fqcnComponent )
      * fqcnComponent = ???
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of LdapComparatorDescription
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static LdapComparatorDescription parseLdapComparatorRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
@@ -4092,6 +4353,13 @@ public class OpenLdapSchemaParser
      *    [ SP "DESC" SP qdstring ]  ; description
      *    extensions WSP RPAREN      ; extensions
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of LdapSyntax
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static LdapSyntax parseLdapSyntaxStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
@@ -4176,6 +4444,13 @@ public class OpenLdapSchemaParser
      *    [ SP "DESC" SP qdstring ]  ; description
      *    extensions WSP RPAREN      ; extensions
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of LdapSyntax
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static LdapSyntax parseLdapSyntaxRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
@@ -4302,6 +4577,13 @@ public class OpenLdapSchemaParser
      *    SP "SYNTAX" SP numericoid  ; assertion syntax
      *    extensions WSP RPAREN      ; extensions
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of MatchingRule
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static MatchingRule parseMatchingRuleStrict( Reader reader, PosSchema pos, 
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
@@ -4428,6 +4710,13 @@ public class OpenLdapSchemaParser
      *    SP "SYNTAX" SP numericoid  ; assertion syntax
      *    extensions WSP RPAREN      ; extensions
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of MatchingRule
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static MatchingRule parseMatchingRuleRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
@@ -4585,8 +4874,15 @@ public class OpenLdapSchemaParser
      *    SP "APPLIES" SP oids       ; attribute types
      *    extensions WSP RPAREN      ; extensions
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of MatchingRuleUse
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
-    private static  MatchingRuleUse parseMatchingRuleUseStrict( Reader reader, PosSchema pos,
+    private static MatchingRuleUse parseMatchingRuleUseStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
@@ -4711,6 +5007,13 @@ public class OpenLdapSchemaParser
      *    SP "APPLIES" SP oids       ; attribute types
      *    extensions WSP RPAREN      ; extensions
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of MatchingRuleUse
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static MatchingRuleUse parseMatchingRuleUseRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
@@ -4872,6 +5175,13 @@ public class OpenLdapSchemaParser
      *    [ SP "MAY" SP oids ]       ; attribute types
      *    extensions WSP RPAREN      ; extensions
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @return An instance of NameForm
+     * @param objectIdentifierMacros The set of existing Macros
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static NameForm parseNameFormStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
@@ -5032,6 +5342,13 @@ public class OpenLdapSchemaParser
      *    [ SP "MAY" SP oids ]       ; attribute types
      *    extensions WSP RPAREN      ; extensions
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of NameForm
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static NameForm parseNameFormRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
@@ -5221,6 +5538,13 @@ public class OpenLdapSchemaParser
      * fqcn = fqcnComponent 1*( DOT fqcnComponent )
      * fqcnComponent = ???
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of NormalizerDescription
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static NormalizerDescription parseNormalizerStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
@@ -5351,6 +5675,13 @@ public class OpenLdapSchemaParser
      * fqcn = fqcnComponent 1*( DOT fqcnComponent )
      * fqcnComponent = ???
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of NormalizerDescription
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static NormalizerDescription parseNormalizerRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
@@ -5509,6 +5840,13 @@ public class OpenLdapSchemaParser
      *
      *   kind = "ABSTRACT" / "STRUCTURAL" / "AUXILIARY"
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of ObjectClass
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static ObjectClass parseObjectClassStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
@@ -5680,6 +6018,13 @@ public class OpenLdapSchemaParser
      *
      *   kind = "ABSTRACT" / "STRUCTURAL" / "AUXILIARY"
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of ObjectClass
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static ObjectClass parseObjectClassRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
@@ -5895,6 +6240,13 @@ public class OpenLdapSchemaParser
      * fqcn = fqcnComponent 1*( DOT fqcnComponent )
      * fqcnComponent = ???
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of SyntaxCheckerDescription
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static SyntaxCheckerDescription parseSyntaxCheckerStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
@@ -6025,6 +6377,13 @@ public class OpenLdapSchemaParser
      * fqcn = fqcnComponent 1*( DOT fqcnComponent )
      * fqcnComponent = ???
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @param objectIdentifierMacros The set of existing Macros
+     * @return An instance of SyntaxCheckerDescription
+     * @throws LdapSchemaException If the schema is wrong
+     * @throws IOException If the stream can't be read
      */
     private static SyntaxCheckerDescription parseSyntaxCheckerRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
@@ -6124,6 +6483,11 @@ public class OpenLdapSchemaParser
      * descr             ::= ALPHA ( ALPHA | DIGIT | HYPHEN )*
      * macroOid         ::= (descr ':')? oid
      * </pre>
+     * 
+     * @param reader The stream reader
+     * @param pos The position in the Schema
+     * @throws LdapSchemaException If something went wrong in the schema
+     * @throws IOException If the stream can't be read
      */
     private void processObjectIdentifier( Reader reader, PosSchema pos ) throws IOException, LdapSchemaException
     {
@@ -6191,8 +6555,9 @@ public class OpenLdapSchemaParser
      *
      * The lines represent *one* entry.
      *
+     * @param reader The stream reader
      * @throws LdapSchemaException If something went wrong in the schema
-     * @throws IOException If something went wrong with the stream
+     * @throws IOException If the stream can't be read
      */
     public void parse( Reader reader ) throws LdapSchemaException, IOException
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/registries/Registries.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/registries/Registries.java
index 1531816..79ab058 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/registries/Registries.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/registries/Registries.java
@@ -1028,6 +1028,9 @@ public class Registries implements SchemaLoaderListener, Cloneable
 
     /**
      * Check AttributeType referential integrity
+     * 
+     * @param attributeType The AttributeType
+     * @param processed The set of superior to check
      */
     private void resolveRecursive( AttributeType attributeType, Set<String> processed )
     {
@@ -1161,6 +1164,8 @@ public class Registries implements SchemaLoaderListener, Cloneable
     /**
      * Check the inheritance, and the existence of MatchingRules and LdapSyntax
      * for an attribute
+     * 
+     * @param attributeType The AttributeType
      */
     private void resolve( AttributeType attributeType )
     {
@@ -1451,6 +1456,9 @@ public class Registries implements SchemaLoaderListener, Cloneable
 
     /**
      * Retrieve the schema name for a specific SchemaObject, or return "other" if none is found.
+     * 
+     * @param schemaObject The SchemaObject
+     * @return The associated Schema
      */
     private String getSchemaName( SchemaObject schemaObject )
     {
@@ -1508,6 +1516,9 @@ public class Registries implements SchemaLoaderListener, Cloneable
 
     /**
      * Register the given SchemaObject into the associated Registry
+     * 
+     * @param schemaObject The SchemaObject to register
+     * @throws LdapException If the SchemaObject cannot be registered
      */
     private void register( SchemaObject schemaObject ) throws LdapException
     {
@@ -1735,6 +1746,7 @@ public class Registries implements SchemaLoaderListener, Cloneable
      * Unregister a SchemaObject from the registries
      *
      * @param schemaObject The SchemaObject we want to deregister
+     * @return The unregistred SchemaObject
      * @throws LdapException If the removal failed
      */
     private SchemaObject unregister( SchemaObject schemaObject ) throws LdapException
@@ -2144,6 +2156,11 @@ public class Registries implements SchemaLoaderListener, Cloneable
 
     /**
      * Dump the reference operation as a String
+     * 
+     * @param op The operation
+     * @param reference The reference
+     * @param referee The referee
+     * @return The resulting string
      */
     private String dump( String op, SchemaObject reference, SchemaObject referee )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/registries/helper/AttributeTypeHelper.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/registries/helper/AttributeTypeHelper.java
index d24b283..5274817 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/registries/helper/AttributeTypeHelper.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/registries/helper/AttributeTypeHelper.java
@@ -145,8 +145,14 @@ public final class AttributeTypeHelper
 
     /**
      * Build the Superior AttributeType reference for an AttributeType
+     * 
+     * @param attributeType The AttributeType to process
+     * @param errorHandler The error handler
+     * @param registries The Registries instance
+     * @return <tt>true</tt> if the AttributeType superiors hierarchy is correct, or if we don't have any superior
      */
-    private static boolean buildSuperior( MutableAttributeType attributeType, SchemaErrorHandler errorHandler, Registries registries )
+    private static boolean buildSuperior( MutableAttributeType attributeType, SchemaErrorHandler errorHandler, 
+            Registries registries )
     {
         MutableAttributeType currentSuperior;
         AttributeTypeRegistry attributeTypeRegistry = registries.getAttributeTypeRegistry();
@@ -272,8 +278,13 @@ public final class AttributeTypeHelper
 
     /**
      * Build the SYNTAX reference for an AttributeType
+     * 
+     * @param attributeType The AttributeType to process
+     * @param errorHandler The error handler
+     * @param registries The Registries instance
      */
-    private static void buildSyntax( MutableAttributeType attributeType, SchemaErrorHandler errorHandler, Registries registries )
+    private static void buildSyntax( MutableAttributeType attributeType, SchemaErrorHandler errorHandler, 
+            Registries registries )
     {
         String syntaxOid = attributeType.getSyntaxOid();
         
@@ -352,8 +363,13 @@ public final class AttributeTypeHelper
     
     /**
      * Build the EQUALITY MR reference for an AttributeType
+     * 
+     * @param attributeType The AttributeType to process
+     * @param errorHandler The error handler
+     * @param registries The Registries instance
      */
-    private static void buildEquality( MutableAttributeType attributeType, SchemaErrorHandler errorHandler, Registries registries )
+    private static void buildEquality( MutableAttributeType attributeType, SchemaErrorHandler errorHandler, 
+            Registries registries )
     {
         String equalityOid = attributeType.getEqualityOid();
         
@@ -414,8 +430,13 @@ public final class AttributeTypeHelper
 
     /**
      * Build the SUBSTR MR reference for an AttributeType
+     * 
+     * @param attributeType The AttributeType to process
+     * @param errorHandler The error handler
+     * @param registries The Registries instance
      */
-    private static void buildSubstring( MutableAttributeType attributeType, SchemaErrorHandler errorHandler, Registries registries )
+    private static void buildSubstring( MutableAttributeType attributeType, SchemaErrorHandler errorHandler,
+            Registries registries )
     {
         String substringOid = attributeType.getSubstringOid();
         
@@ -473,8 +494,13 @@ public final class AttributeTypeHelper
     
     /**
      * Build the ORDERING MR reference for an AttributeType
+     * 
+     * @param attributeType The AttributeType to process
+     * @param errorHandler The error handler
+     * @param registries The Registries instance
      */
-    private static void buildOrdering( MutableAttributeType attributeType, SchemaErrorHandler errorHandler, Registries registries )
+    private static void buildOrdering( MutableAttributeType attributeType, SchemaErrorHandler errorHandler, 
+            Registries registries )
     {
         String orderingOid = attributeType.getOrderingOid();
         
@@ -531,6 +557,9 @@ public final class AttributeTypeHelper
     
     /**
      * Check the constraints for the Usage field.
+     * 
+     * @param attributeType The AttributeType to check
+     * @param errorHandler The error handler
      */
     private static void checkUsage( AttributeType attributeType, SchemaErrorHandler errorHandler )
     {
@@ -566,6 +595,9 @@ public final class AttributeTypeHelper
 
     /**
      * Check the constraints for the Collective field.
+     * 
+     * @param attributeType The AttributeType to check
+     * @param errorHandler The error handler
      */
     private static void checkCollective( MutableAttributeType attributeType, SchemaErrorHandler errorHandler )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/registries/helper/ObjectClassHelper.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/registries/helper/ObjectClassHelper.java
index c6e1d02..e736796 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/registries/helper/ObjectClassHelper.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/registries/helper/ObjectClassHelper.java
@@ -107,6 +107,10 @@ public final class ObjectClassHelper
     /**
      * Build the references to this ObjectClass SUPERIORS, checking that the type
      * hierarchy is correct.
+     * 
+     * @param objectClass The oOjectClass to process
+     * @param errorHandler The error handler
+     * @param registries The Registries instance
      */
     private static void buildSuperiors( ObjectClass objectClass, SchemaErrorHandler errorHandler, Registries registries )
     {
@@ -203,6 +207,10 @@ public final class ObjectClassHelper
 
     /**
      * Build and check the MUST AT for this ObjectClass.
+     * 
+     * @param objectClass The oOjectClass to process
+     * @param errorHandler The error handler
+     * @param registries The Registries instance
      */
     private static void buildMust( ObjectClass objectClass, SchemaErrorHandler errorHandler, Registries registries )
     {
@@ -287,6 +295,10 @@ public final class ObjectClassHelper
     
     /**
      * Build and check the MAY AT for this ObjectClass
+     * 
+     * @param objectClass The oOjectClass to process
+     * @param errorHandler The error handler
+     * @param registries The Registries instance
      */
     private static void buildMay( ObjectClass objectClass, SchemaErrorHandler errorHandler, Registries registries )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/FacsimileTelephoneNumberSyntaxChecker.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/FacsimileTelephoneNumberSyntaxChecker.java
index 0125184..535532c 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/FacsimileTelephoneNumberSyntaxChecker.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/FacsimileTelephoneNumberSyntaxChecker.java
@@ -118,6 +118,7 @@ public final class FacsimileTelephoneNumberSyntaxChecker extends SyntaxChecker
         
         /**
          * Create a new instance of FacsimileTelephoneNumberSyntaxChecker
+         * 
          * @return A new instance of FacsimileTelephoneNumberSyntaxChecker
          */
         @Override
@@ -131,6 +132,7 @@ public final class FacsimileTelephoneNumberSyntaxChecker extends SyntaxChecker
          * Set the default regular expression for the Telephone number
          * 
          * @param regexp the default regular expression.
+         * @return The FacsimileTelephneNumber Builder instance
          */
         public Builder setDefaultRegexp( String regexp )
         {
@@ -153,6 +155,8 @@ public final class FacsimileTelephoneNumberSyntaxChecker extends SyntaxChecker
     
     /**
      * Creates a new instance of TelephoneNumberSyntaxChecker.
+     * 
+     * @param oid the OID
      */
     private FacsimileTelephoneNumberSyntaxChecker( String oid )
     {
@@ -162,6 +166,10 @@ public final class FacsimileTelephoneNumberSyntaxChecker extends SyntaxChecker
     
     /**
      * Creates a new instance of TelephoneNumberSyntaxChecker.
+     * 
+     * @param oid The OID
+     * @param defaultRegexp the default regexp to use
+     * @param defaultPattern The default pattern to use
      */
     private FacsimileTelephoneNumberSyntaxChecker( String oid, String defaultRegexp, Pattern defaultPattern )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/OidLenSyntaxChecker.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/OidLenSyntaxChecker.java
index b729013..3209fc6 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/OidLenSyntaxChecker.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/OidLenSyntaxChecker.java
@@ -84,7 +84,8 @@ public final class OidLenSyntaxChecker extends SyntaxChecker
     /**
      * 
      * Creates a new instance of OidLenSyntaxChecker.
-     *
+     * 
+     * @param oid The OID
      */
     private OidLenSyntaxChecker( String oid )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/OtherMailboxSyntaxChecker.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/OtherMailboxSyntaxChecker.java
index de1ad34..d8fe731 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/OtherMailboxSyntaxChecker.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/OtherMailboxSyntaxChecker.java
@@ -73,6 +73,8 @@ public final class OtherMailboxSyntaxChecker extends SyntaxChecker
     
     /**
      * Creates a new instance of OtherMailboxSyntaxChecker.
+     * 
+     * @param oid The OID
      */
     private OtherMailboxSyntaxChecker( String oid )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/RegexSyntaxChecker.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/RegexSyntaxChecker.java
index eb2e798..370fac8 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/RegexSyntaxChecker.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/RegexSyntaxChecker.java
@@ -58,6 +58,7 @@ public final class RegexSyntaxChecker extends SyntaxChecker
          * Add a list of regexp to be applied by this SyntaxChecker
          * 
          * @param expressions The regexp list to add
+         * @return the RegexSyntaxChecker Builder instance
          */
         public Builder setExpressions( String[] expressions )
         {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/SubtreeSpecificationSyntaxChecker.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/SubtreeSpecificationSyntaxChecker.java
index 6a7c3db..90fb567 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/SubtreeSpecificationSyntaxChecker.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/SubtreeSpecificationSyntaxChecker.java
@@ -89,6 +89,7 @@ public final class SubtreeSpecificationSyntaxChecker extends SyntaxChecker
      * Creates an instance of SubtreeSpecificationSyntaxChecker
      * 
      * @param oid The OID to use for this SyntaxChecker
+     * @param schemaManager the SchemaManager instance
      */
     private SubtreeSpecificationSyntaxChecker( String oid, SchemaManager schemaManager )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/TelephoneNumberSyntaxChecker.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/TelephoneNumberSyntaxChecker.java
index 9ef7e30..3f249f6 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/TelephoneNumberSyntaxChecker.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/schema/syntaxCheckers/TelephoneNumberSyntaxChecker.java
@@ -98,6 +98,7 @@ public final class TelephoneNumberSyntaxChecker extends SyntaxChecker
          * Set the default regular expression for the Telephone number
          * 
          * @param regexp the default regular expression.
+         * @return the TelephonenumberSyntaxChecker Builder instance
          */
         public Builder setDefaultRegexp( String regexp )
         {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/AdministrativeRole.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/AdministrativeRole.java
index 84b3d48..7221a22 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/AdministrativeRole.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/AdministrativeRole.java
@@ -60,6 +60,8 @@ public enum AdministrativeRole
 
     /**
      * Creates an instance of AdministrativeRole
+     * 
+     * @param role The role's name
      */
     AdministrativeRole( String role )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/ReusableAntlrSubtreeSpecificationChecker.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/ReusableAntlrSubtreeSpecificationChecker.java
index 9ca02cc..bf62aef 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/ReusableAntlrSubtreeSpecificationChecker.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/ReusableAntlrSubtreeSpecificationChecker.java
@@ -40,6 +40,8 @@ class ReusableAntlrSubtreeSpecificationChecker extends AntlrSubtreeSpecification
 {
     /**
      * Creates a ReusableAntlrSubtreeSpecificationParser instance.
+     * 
+     * @param lexer The Token stream
      */
     ReusableAntlrSubtreeSpecificationChecker( TokenStream lexer )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/ReusableAntlrSubtreeSpecificationParser.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/ReusableAntlrSubtreeSpecificationParser.java
index 21e07d1..0eef080 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/ReusableAntlrSubtreeSpecificationParser.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/ReusableAntlrSubtreeSpecificationParser.java
@@ -40,6 +40,8 @@ class ReusableAntlrSubtreeSpecificationParser extends AntlrSubtreeSpecificationP
 {
     /**
      * Creates a ReusableAntlrSubtreeSpecificationParser instance.
+     * 
+     * @param lexer The Token stream
      */
     ReusableAntlrSubtreeSpecificationParser( TokenStream lexer )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/SubtreeSpecificationParser.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/SubtreeSpecificationParser.java
index 0f27fcf..9b131a8 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/SubtreeSpecificationParser.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/subtree/SubtreeSpecificationParser.java
@@ -1,4 +1,6 @@
 /*
+
+
  *  Licensed to the Apache Software Foundation (ASF) under one
  *  or more contributor license agreements.  See the NOTICE file
  *  distributed with this work for additional information
@@ -94,7 +96,9 @@ public class SubtreeSpecificationParser
 
     /**
      * Initializes the plumbing by creating a pipe and coupling the parser/lexer
-     * pair with it. param spec the specification to be parsed
+     * pair with it.
+     * 
+     * @param spec The specification to parse
      */
     private synchronized void reset( String spec )
     {
diff --git a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/url/LdapUrl.java b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/url/LdapUrl.java
index a73703e..70c3d8c 100644
--- a/ldap/model/src/main/java/org/apache/directory/api/ldap/model/url/LdapUrl.java
+++ b/ldap/model/src/main/java/org/apache/directory/api/ldap/model/url/LdapUrl.java
@@ -441,6 +441,10 @@ public class LdapUrl
      * h16         = 1*4HEXDIG
      * ls32        = ( h16 ":" h16 ) / IPv4address
      * </pre>
+     * 
+     * @param chars The chars to parse
+     * @param pos The position in the chars
+     * @return The new position, or -1 if we had an error
      */
     private int parseIpLiteral( char[] chars, int pos )
     {
@@ -474,6 +478,7 @@ public class LdapUrl
 
     /**
      * Validates an IPv4 address. Returns true if valid.
+     * 
      * @param inet4Address the IPv4 address to validate
      * @return true if the argument contains a valid IPv4 address
      */
@@ -623,6 +628,10 @@ public class LdapUrl
      * h16         = 1*4HEXDIG
      * ls32        = ( h16 ":" h16 ) / IPv4address
      * </pre>
+     * 
+     * @param chars The chars to parse
+     * @param pos The position in the chars
+     * @return The new position, or -1 if we had an error
      */
     private int parseIPV6( char[] chars, int pos )
     {
@@ -660,6 +669,10 @@ public class LdapUrl
      * IPvFuture   = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
      * </pre>
      * (the "v" has already been parsed)
+     * 
+     * @param chars The chars to parse
+     * @param pos The position in the chars
+     * @return The new position, or -1 if we had an error
      */
     private int parseIPvFuture( char[] chars, int pos )
     {
@@ -746,6 +759,10 @@ public class LdapUrl
      * sub-delims  = "!" | "$" | "&amp;" | "'" | "(" | ")" | "*" | "+" | "," | ";" | "="
      * HEXDIG      = DIGIT / A-F / a-f
      * </pre>
+     * 
+     * @param chars The chars to parse
+     * @param pos The position in the chars
+     * @return The new position, or -1 if we had an error
      */
     private int parseRegName( char[] chars, int pos )
     {
@@ -815,6 +832,7 @@ public class LdapUrl
      * IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
      * dec-octet   = DIGIT | [1-9] DIGIT | "1" 2DIGIT | "2" [0-4] DIGIT | "25" [0-5]
      * </pre>
+     * 
      * @param chars The buffer to parse
      * @param pos The current position in the byte buffer
      * 
@@ -870,6 +888,12 @@ public class LdapUrl
      * <pre>
      * dec-octet   = DIGIT | [1-9] DIGIT | "1" 2DIGIT | "2" [0-4] DIGIT | "25" [0-5]
      * </pre>
+     * 
+     * @param chars The chars to parse 
+     * @param pos The position in the chars
+     * @param ipElem The IP elements to update
+     * @param octetNb The IP octet being processed
+     * @return The new position, or -1 if the IP octet is invalid
      */
     private int parseDecOctet( char[] chars, int pos, int[] ipElem, int octetNb )
     {
@@ -1148,8 +1172,8 @@ public class LdapUrl
      * number ::= 0 | [1-9][0-9]* 
      * </pre>
      * 
-     * @param attribute
-     * @throws LdapURLEncodingException
+     * @param attribute The attribute to validate
+     * @throws LdapURLEncodingException If teh attribute is invalid
      */
     private void validateAttribute( String attribute ) throws LdapURLEncodingException
     {
diff --git a/ldap/model/src/test/java/org/apache/directory/api/ldap/model/schema/comparators/IntegerComparatorTest.java b/ldap/model/src/test/java/org/apache/directory/api/ldap/model/schema/comparators/IntegerComparatorTest.java
new file mode 100644
index 0000000..8567e03
--- /dev/null
+++ b/ldap/model/src/test/java/org/apache/directory/api/ldap/model/schema/comparators/IntegerComparatorTest.java
@@ -0,0 +1,81 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *  
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *  
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License. 
+ *  
+ */
+package org.apache.directory.api.ldap.model.schema.comparators;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import com.mycila.junit.concurrent.Concurrency;
+import com.mycila.junit.concurrent.ConcurrentJunitRunner;
+
+/**
+ * Test the Integer comparator
+ * 
+ * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
+ */
+@RunWith(ConcurrentJunitRunner.class)
+@Concurrency()
+public class IntegerComparatorTest 
+{
+    private IntegerComparator comparator;
+
+    @Before
+    public void init()
+    {
+        comparator = new IntegerComparator( null );
+    }
+
+    
+    @Test
+    public void testNullIntegers()
+    {
+        assertEquals( 0, comparator.compare( null, null ) );
+
+        String int1 = "1";
+        assertEquals( -1, comparator.compare( ( String ) null, int1 ) );
+
+        assertEquals( 1, comparator.compare( int1, ( String ) null ) );
+    }
+
+    
+    @Test 
+    public void testBigIntegerValues()
+    {
+        assertEquals( -1, comparator.compare( null, "1000000000000000000000000" ) );
+        assertEquals( 1, comparator.compare( "1000000000000000000000000", null ) );
+        assertEquals( 0, comparator.compare( "1000000000000000000000000", "1000000000000000000000000" ) );
+        
+        long t0 = System.currentTimeMillis();
+        
+        for ( int i = 0; i < 10000000; i++ )
+        {
+            assertEquals( -1, comparator.compare( "9223372036854775805", "9223372036854775806" ) );
+        }
+        
+        long t1 = System.currentTimeMillis();
+        
+        System.out.println( "Delta = " + ( t1 - t0 ) );
+        
+            assertEquals( 1, comparator.compare( "1000000000000000000000001", "1000000000000000000000000" ) );
+    }
+}


Mime
View raw message