LdifReader (Apache Directory LDAP API Model 2.1.2 API)

java.lang.Object
- org.apache.directory.api.ldap.model.ldif.LdifReader

All Implemented Interfaces:: Closeable, AutoCloseable, Iterable<LdifEntry>

Direct Known Subclasses:: LdifAttributesReader

public class LdifReader
extends Object
implements Iterable<LdifEntry>, Closeable

  <ldif-file> ::= "version:" <fill> <number> <seps> <dn-spec> <sep>
  <ldif-content-change>

  <ldif-content-change> ::=
    <number> <oid> <options-e> <value-spec> <sep>
    <attrval-specs-e> <ldif-attrval-record-e> |
    <alpha> <chars-e> <options-e> <value-spec> <sep>
    <attrval-specs-e> <ldif-attrval-record-e> |
    "control:" <fill> <number> <oid> <spaces-e>
    <criticality> <value-spec-e> <sep> <controls-e>
        "changetype:" <fill> <changerecord-type> <ldif-change-record-e> |
    "changetype:" <fill> <changerecord-type> <ldif-change-record-e>

  <ldif-attrval-record-e> ::= <seps> <dn-spec> <sep> <attributeType>
    <options-e> <value-spec> <sep> <attrval-specs-e>
    <ldif-attrval-record-e> | e

  <ldif-change-record-e> ::= <seps> <dn-spec> <sep> <controls-e>
    "changetype:" <fill> <changerecord-type> <ldif-change-record-e> | e

  <dn-spec> ::= "dn:" <fill> <safe-string> | "dn::" <fill> <base64-string>

  <controls-e> ::= "control:" <fill> <number> <oid> <spaces-e> <criticality>
    <value-spec-e> <sep> <controls-e> | e

  <criticality> ::= "true" | "false" | e

  <oid> ::= '.' <number> <oid> | e

  <attrval-specs-e> ::= <number> <oid> <options-e> <value-spec>
  <sep> <attrval-specs-e> |
    <alpha> <chars-e> <options-e> <value-spec> <sep> <attrval-specs-e> | e

  <value-spec-e> ::= <value-spec> | e

  <value-spec> ::= ':' <fill> <safe-string-e> |
    "::" <fill> <base64-chars> |
    ":<" <fill> <url>

  <attributeType> ::= <number> <oid> | <alpha> <chars-e>

  <options-e> ::= ';' <char> <chars-e> <options-e> |e

  <chars-e> ::= <char> <chars-e> |  e

  <changerecord-type> ::= "add" <sep> <attributeType>
  <options-e> <value-spec> <sep> <attrval-specs-e> |
    "delete" <sep> |
    "modify" <sep> <mod-type> <fill> <attributeType>
    <options-e> <sep> <attrval-specs-e> <sep> '-' <sep> <mod-specs-e> |
    "moddn" <sep> <newrdn> <sep> "deleteoldrdn:"
    <fill> <0-1> <sep> <newsuperior-e> <sep> |
    "modrdn" <sep> <newrdn> <sep> "deleteoldrdn:"
    <fill> <0-1> <sep> <newsuperior-e> <sep>

  <newrdn> ::= ':' <fill> <safe-string> | "::" <fill> <base64-chars>

  <newsuperior-e> ::= "newsuperior" <newrdn> | e

  <mod-specs-e> ::= <mod-type> <fill> <attributeType> <options-e>
    <sep> <attrval-specs-e> <sep> '-' <sep> <mod-specs-e> | e

  <mod-type> ::= "add:" | "delete:" | "replace:"

  <url> ::= <a Uniform Resource Locator, as defined in [6]>



  LEXICAL
  -------

  <fill>           ::= ' ' <fill> | e
  <char>           ::= <alpha> | <digit> | '-'
  <number>         ::= <digit> <digits>
  <0-1>            ::= '0' | '1'
  <digits>         ::= <digit> <digits> | e
  <digit>          ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
  <seps>           ::= <sep> <seps-e>
  <seps-e>         ::= <sep> <seps-e> | e
  <sep>            ::= 0x0D 0x0A | 0x0A
  <spaces>         ::= ' ' <spaces-e>
  <spaces-e>       ::= ' ' <spaces-e> | e
  <safe-string-e>  ::= <safe-string> | e
  <safe-string>    ::= <safe-init-char> <safe-chars>
  <safe-init-char> ::= [0x01-0x09] | 0x0B | 0x0C | [0x0E-0x1F] | [0x21-0x39] | 0x3B | [0x3D-0x7F]
  <safe-chars>     ::= <safe-char> <safe-chars> | e
  <safe-char>      ::= [0x01-0x09] | 0x0B | 0x0C | [0x0E-0x7F]
  <base64-string>  ::= <base64-char> <base64-chars>
  <base64-chars>   ::= <base64-char> <base64-chars> | e
  <base64-char>    ::= 0x2B | 0x2F | [0x30-0x39] | 0x3D | [0x41-9x5A] | [0x61-0x7A]
  <alpha>          ::= [0x41-0x5A] | [0x61-0x7A]

  COMMENTS
  --------
  - The ldap-oid VN is not correct in the RFC-2849. It has been changed from 1*DIGIT 0*1("." 1*DIGIT) to
  DIGIT+ ("." DIGIT+)*
  - The mod-spec lacks a sep between *attrval-spec and "-".
  - The BASE64-UTF8-STRING should be BASE64-CHAR BASE64-STRING
  - The ValueSpec rule must accept multilines values. In this case, we have a LF followed by a
  single space before the continued value.

The relaxed mode is used when a SchemaManager is injected.

Author:: Apache Directory Project

Field Summary

Fields
Modifier and Type	Field and Description
`protected static int`	`ATTRVAL_SPEC` State values for the modify operation : ATTRVAL_SPEC
`protected static int`	`ATTRVAL_SPEC_OR_SEP` State values for the modify operation : ATTRVAL_SPEC_OR_SEP
`protected static int`	`CHANGE` Type of element read : CHANGE
`protected boolean`	`containsChanges` A flag set if the ldif contains changes
`protected boolean`	`containsEntries` A flag set if the ldif contains entries
`protected static int`	`DEFAULT_VERSION` The ldif file version default value
`protected int`	`entryLen` total length of an LDIF entry including the comments
`protected long`	`entryOffset` the parsed entry's starting position
`protected Exception`	`error` An Exception to handle error message, has Iterator.next() can't throw exceptions
`private InputStream`	`is` The internal inputStream
`protected static int`	`LDIF_ENTRY` Type of element read : ENTRY
`protected int`	`lineNumber` the numer of the current line being parsed by the reader
`protected List<String>`	`lines` A list of read lines
`private static org.slf4j.Logger`	`LOG` A logger
`protected static int`	`MOD_SPEC` State values for the modify operation : MOD_SPEC
`protected long`	`offset` the current offset of the reader
`private int`	`oidCounter` A counter used to create facked OIDs
`protected int`	`position` The current position
`protected LdifEntry`	`prefetched` Iterator prefetched entry
`protected Reader`	`reader` The ldif Reader
`protected SchemaManager`	`schemaManager` The SchemaManager instance, if any
`protected static long`	`SIZE_LIMIT_DEFAULT` The default size limit : 1Mo
`protected long`	`sizeLimit` Size limit for file contained values
`protected static int`	`UNKNOWN` Type of element read : UNKNOWN
`protected boolean`	`validateDn` flag to turn on/off of the DN validation.
`protected int`	`version` The ldif version

Constructor Summary

Constructors
Constructor and Description
`LdifReader()` Constructors
`LdifReader(File file)` A constructor which takes a File.
`LdifReader(File file, SchemaManager schemaManager)` A constructor which takes a File and a SchemaManager.
`LdifReader(InputStream in)` A constructor which takes an InputStream.
`LdifReader(Reader in)` A constructor which takes a Reader.
`LdifReader(SchemaManager schemaManager)` Creates a Schema aware reader
`LdifReader(String ldifFileName)` A constructor which takes a file name.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`close()`
`boolean`	`containsEntries()`
`protected LdifEntry`	`createLdifEntry(SchemaManager schemaManager)` Creates a schema aware LdifEntry
`LdifEntry`	`fetch()` Gets the current entry, but don't move forward.
`Exception`	`getError()`
`protected String`	`getLine()` gets a line from the underlying data store
`int`	`getLineNumber()`
`long`	`getSizeLimit()`
`private Object`	`getValue(String attributeName, byte[] value)`
`int`	`getVersion()`
`boolean`	`hasError()`
`boolean`	`hasNext()` Tests to see if another LDIF is on the input channel.
`private boolean`	`hasNextInternal()` Tests to see if another LDIF is on the input channel.
`void`	`init()` Initialize the LdifReader
`private void`	`initReader(BufferedReader reader)` Store the reader and initialize the LdifReader
`boolean`	`isValidateDn()`
`Iterator<LdifEntry>`	`iterator()`
`LdifEntry`	`next()` Gets the next LDIF on the channel.
`private LdifEntry`	`nextInternal()` Gets the next LDIF on the channel.
`void`	`parseAttributeValue(LdifEntry entry, String line, String lowerLine)` Parse an AttributeType/AttributeValue
`static Attribute`	`parseAttributeValue(String line)` Parse an AttributeType/AttributeValue
`private void`	`parseChange(LdifEntry entry, Iterator<String> iter, ChangeType operation)` Parse a change operation.
`protected ChangeType`	`parseChangeType(String line)` Parse the changeType
`private Control`	`parseControl(String line)` Parse a control.
`protected String`	`parseDn(String line)` Parse the Dn of an entry
`protected LdifEntry`	`parseEntry()` Parse a ldif file.
`private void`	`parseFill(char[] document)`
`List<LdifEntry>`	`parseLdif(BufferedReader reader)` The main entry point of the LdifParser.
`List<LdifEntry>`	`parseLdif(String ldif)` A method which parses a ldif string and returns a list of entries.
`List<LdifEntry>`	`parseLdifFile(String fileName)` Parse a ldif file (using the default encoding).
`List<LdifEntry>`	`parseLdifFile(String fileName, String encoding)` Parse a ldif file, decoding it using the given charset encoding
`private void`	`parseModify(LdifEntry entry, Iterator<String> iter)` Parse a modify change type.
`private void`	`parseModRdn(LdifEntry entry, Iterator<String> iter)` Parse a ModRDN operation
`private String`	`parseNumber(char[] document)` Parse a number following the rules : <number> ::= <digit> <digits> <digits> ::= <digit> <digits> \| e <digit> ::= '0' \| '1' \| '2' \| '3' \| '4' \| '5' \| '6' \| '7' \| '8' \| '9' Check that the number is in the interval
`protected static Object`	`parseSimpleValue(String line, int pos)` Parse the value part.
`protected Object`	`parseValue(String attributeName, String line, int pos)` Parse the value part.
`protected int`	`parseVersion()` Parse the version from the ldif input.
`protected void`	`readLines()` Reads an entry in a ldif buffer, and returns the resulting lines, without comments, and unfolded.
`void`	`remove()` Always throws UnsupportedOperationException!
`private void`	`removeInternal()` Always throws UnsupportedOperationException!
`void`	`setSchemaManager(SchemaManager schemaManager)`
`void`	`setSizeLimit(long sizeLimit)` Set the maximum file size that can be accepted for an attribute value
`void`	`setValidateDn(boolean validateDn)` Turns on/off the DN validation

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Field Detail
  - LOG
```
private static final org.slf4j.Logger LOG
```
    A logger
  - lines
```
protected List<String> lines
```
    A list of read lines
  - position
```
protected int position
```
    The current position
  - DEFAULT_VERSION
```
protected static final int DEFAULT_VERSION
```
    The ldif file version default value
    
    See Also:
    
    Constant Field Values
  - version
```
protected int version
```
    The ldif version
  - LDIF_ENTRY
```
protected static final int LDIF_ENTRY
```
    Type of element read : ENTRY
    
    See Also:
    
    Constant Field Values
  - CHANGE
```
protected static final int CHANGE
```
    Type of element read : CHANGE
    
    See Also:
    
    Constant Field Values
  - UNKNOWN
```
protected static final int UNKNOWN
```
    Type of element read : UNKNOWN
    
    See Also:
    
    Constant Field Values
  - sizeLimit
```
protected long sizeLimit
```
    Size limit for file contained values
  - SIZE_LIMIT_DEFAULT
```
protected static final long SIZE_LIMIT_DEFAULT
```
    The default size limit : 1Mo
    
    See Also:
    
    Constant Field Values
  - MOD_SPEC
```
protected static final int MOD_SPEC
```
    State values for the modify operation : MOD_SPEC
    
    See Also:
    
    Constant Field Values
  - ATTRVAL_SPEC
```
protected static final int ATTRVAL_SPEC
```
    State values for the modify operation : ATTRVAL_SPEC
    
    See Also:
    
    Constant Field Values
  - ATTRVAL_SPEC_OR_SEP
```
protected static final int ATTRVAL_SPEC_OR_SEP
```
    State values for the modify operation : ATTRVAL_SPEC_OR_SEP
    
    See Also:
    
    Constant Field Values
  - prefetched
```
protected LdifEntry prefetched
```
    Iterator prefetched entry
  - reader
```
protected Reader reader
```
    The ldif Reader
  - is
```
private InputStream is
```
    The internal inputStream
  - containsEntries
```
protected boolean containsEntries
```
    A flag set if the ldif contains entries
  - containsChanges
```
protected boolean containsChanges
```
    A flag set if the ldif contains changes
  - schemaManager
```
protected SchemaManager schemaManager
```
    The SchemaManager instance, if any
  - error
```
protected Exception error
```
    An Exception to handle error message, has Iterator.next() can't throw exceptions
  - entryLen
```
protected int entryLen
```
    total length of an LDIF entry including the comments
  - entryOffset
```
protected long entryOffset
```
    the parsed entry's starting position
  - offset
```
protected long offset
```
    the current offset of the reader
  - lineNumber
```
protected int lineNumber
```
    the numer of the current line being parsed by the reader
  - validateDn
```
protected boolean validateDn
```
    flag to turn on/off of the DN validation. By default DNs are validated after parsing
  - oidCounter
```
private int oidCounter
```
    A counter used to create facked OIDs
- Constructor Detail
  - LdifReader
```
public LdifReader()
```
    Constructors
  - LdifReader
```
public LdifReader(SchemaManager schemaManager)
```
    Creates a Schema aware reader
    
    Parameters:
    
    schemaManager - The SchemaManager
  - LdifReader
```
public LdifReader(String ldifFileName)
           throws LdapLdifException
```
    A constructor which takes a file name. Default charset is used.
    
    Parameters:
    
    ldifFileName - A file name containing ldif formated input
    
    Throws:
    
    LdapLdifException - If the file cannot be processed or if the format is incorrect
  - LdifReader
```
public LdifReader(Reader in)
           throws LdapException
```
    A constructor which takes a Reader.
    
    Parameters:
    
    in - A Reader containing ldif formated input
    
    Throws:
    
    LdapException - If the file cannot be processed or if the format is incorrect
  - LdifReader
```
public LdifReader(InputStream in)
           throws LdapException
```
    A constructor which takes an InputStream. Default charset is used.
    
    Parameters:
    
    in - An InputStream containing ldif formated input
    
    Throws:
    
    LdapException - If the file cannot be processed or if the format is incorrect
  - LdifReader
```
public LdifReader(File file)
           throws LdapLdifException
```
    A constructor which takes a File. Default charset is used.
    
    Parameters:
    
    file - A File containing ldif formated input
    
    Throws:
    
    LdapLdifException - If the file cannot be processed or if the format is incorrect
  - LdifReader
```
public LdifReader(File file,
                  SchemaManager schemaManager)
           throws LdapLdifException
```
    A constructor which takes a File and a SchemaManager. Default charset is used.
    
    Parameters:
    
    file - A File containing ldif formated input
    
    schemaManager - The SchemaManager instance to use
    
    Throws:
    
    LdapLdifException - If the file cannot be processed or if the format is incorrect
- Method Detail
  - initReader
```
private void initReader(BufferedReader reader)
                 throws LdapException
```
    Store the reader and initialize the LdifReader
    
    Parameters:
    
    reader - The reader to use
    
    Throws:
    
    LdapException - If the initialization failed
  - init
```
public void init()
          throws LdapException
```
    Initialize the LdifReader
    
    Throws:
    
    LdapException - If the initialization failed
  - getVersion
```
public int getVersion()
```
    Returns:
    
    The ldif file version
  - getSizeLimit
```
public long getSizeLimit()
```
    Returns:
    
    The maximum size of a file which is used into an attribute value.
  - setSizeLimit
```
public void setSizeLimit(long sizeLimit)
```
    Set the maximum file size that can be accepted for an attribute value
    
    Parameters:
    
    sizeLimit - The size in bytes
  - parseFill
```
private void parseFill(char[] document)
```
  - parseNumber
```
private String parseNumber(char[] document)
```
    Parse a number following the rules : <number> ::= <digit> <digits> <digits> ::= <digit> <digits> | e <digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' Check that the number is in the interval
    
    Parameters:
    
    document - The document containing the number to parse
    
    Returns:
    
    a String representing the parsed number
  - parseChangeType
```
protected ChangeType parseChangeType(String line)
```
    Parse the changeType
    
    Parameters:
    
    line - The line which contains the changeType
    
    Returns:
    
    The operation.
  - parseDn
```
protected String parseDn(String line)
                  throws LdapLdifException
```
    Parse the Dn of an entry
    
    Parameters:
    
    line - The line to parse
    
    Returns:
    
    A Dn
    
    Throws:
    
    LdapLdifException - If the Dn is invalid
  - parseSimpleValue
```
protected static Object parseSimpleValue(String line,
                                         int pos)
```
    Parse the value part.
    
    Parameters:
    
    line - The line which contains the value
    
    pos - The starting position in the line
    
    Returns:
    
    A String or a byte[], depending of the kind of value we get
  - getValue
```
private Object getValue(String attributeName,
                        byte[] value)
```
  - parseValue
```
protected Object parseValue(String attributeName,
                            String line,
                            int pos)
                     throws LdapLdifException
```
    Parse the value part.
    
    Parameters:
    
    attributeName - The attribute name
    
    line - The line which contains the value
    
    pos - The starting position in the line
    
    Returns:
    
    A String or a byte[], depending of the kind of value we get
    
    Throws:
    
    LdapLdifException - If something went wrong
  - parseControl
```
private Control parseControl(String line)
                      throws LdapLdifException
```
    Parse a control. The grammar is :
```
 <control> ::= "control:" <fill> <ldap-oid> <critical-e> <value-spec-e> <sep>
 <critical-e> ::= <spaces> <boolean> | e
 <boolean> ::= "true" | "false"
 <value-spec-e> ::= <value-spec> | e
 <value-spec> ::= ":" <fill> <SAFE-STRING-e> | "::" <fill> <BASE64-STRING> | ":<" <fill> <url>
 
```
    It can be read as :
```
 "control:" <fill> <ldap-oid> [ " "+ ( "true" |
 "false") ] [ ":" <fill> <SAFE-STRING-e> | "::" <fill> <BASE64-STRING> | ":<"
 <fill> <url> ]
 
```
    Parameters:
    
    line - The line containing the control
    
    Returns:
    
    A control
    
    Throws:
    
    LdapLdifException - If the control has no OID or if the OID is incorrect, of if the criticality is not set when it's mandatory.
  - parseAttributeValue
```
public static Attribute parseAttributeValue(String line)
```
    Parse an AttributeType/AttributeValue
    
    Parameters:
    
    line - The line to parse
    
    Returns:
    
    the parsed Attribute
  - parseAttributeValue
```
public void parseAttributeValue(LdifEntry entry,
                                String line,
                                String lowerLine)
                         throws LdapException
```
    Parse an AttributeType/AttributeValue
    
    Parameters:
    
    entry - The entry where to store the value
    
    line - The line to parse
    
    lowerLine - The same line, lowercased
    
    Throws:
    
    LdapException - If anything goes wrong
  - parseModRdn
```
private void parseModRdn(LdifEntry entry,
                         Iterator<String> iter)
                  throws LdapLdifException
```
    Parse a ModRDN operation
    
    Parameters:
    
    entry - The entry to update
    
    iter - The lines iterator
    
    Throws:
    
    LdapLdifException - If anything goes wrong
  - parseModify
```
private void parseModify(LdifEntry entry,
                         Iterator<String> iter)
                  throws LdapLdifException
```
    Parse a modify change type. The grammar is :
```
 <changerecord> ::= "changetype:" FILL "modify" SEP <mod-spec> <mod-specs-e>
 <mod-spec> ::= "add:" <mod-val> | "delete:" <mod-val-del> | "replace:" <mod-val>
                      | "increment:" <mod-val>
 <mod-specs-e> ::= <mod-spec>
 <mod-specs-e> | e
 <mod-val> ::= FILL ATTRIBUTE-DESCRIPTION SEP ATTRVAL-SPEC <attrval-specs-e> "-" SEP
 <mod-val-del> ::= FILL ATTRIBUTE-DESCRIPTION SEP <attrval-specs-e> "-" SEP
 <attrval-specs-e> ::= ATTRVAL-SPEC <attrval-specs> | e
 
```
    Parameters:
    
    entry - The entry to feed
    
    iter - The lines
    
    Throws:
    
    LdapLdifException - If the modify operation is invalid
  - parseChange
```
private void parseChange(LdifEntry entry,
                         Iterator<String> iter,
                         ChangeType operation)
                  throws LdapException
```
    Parse a change operation. We have to handle different cases depending on the operation.
    - 1) Delete : there should *not* be any line after the "changetype: delete"
    - 2) Add : we must have a list of AttributeType : AttributeValue elements
    - 3) ModDN : we must have two following lines: a "newrdn:" and a "deleteoldrdn:"
    - 4) ModRDN : the very same, but a "newsuperior:" line is expected
    - 5) Modify
    The grammar is :
```
 <changerecord> ::= "changetype:" FILL "add" SEP <attrval-spec> <attrval-specs-e> |
     "changetype:" FILL "delete" |
     "changetype:" FILL "modrdn" SEP <newrdn> SEP <deleteoldrdn> SEP |
     // To be checked
     "changetype:" FILL "moddn" SEP <newrdn> SEP <deleteoldrdn> SEP <newsuperior> SEP |
     "changetype:" FILL "modify" SEP <mod-spec> <mod-specs-e>
 <newrdn> ::= "newrdn:" FILL Rdn | "newrdn::" FILL BASE64-Rdn
 <deleteoldrdn> ::= "deleteoldrdn:" FILL "0" | "deleteoldrdn:" FILL "1"
 <newsuperior> ::= "newsuperior:" FILL Dn | "newsuperior::" FILL BASE64-Dn
 <mod-specs-e> ::= <mod-spec> <mod-specs-e> | e
 <mod-spec> ::= "add:" <mod-val> | "delete:" <mod-val> | "replace:" <mod-val>
 <mod-val> ::= FILL ATTRIBUTE-DESCRIPTION SEP ATTRVAL-SPEC <attrval-specs-e> "-" SEP
 <attrval-specs-e> ::= ATTRVAL-SPEC <attrval-specs> | e
 
```
    Parameters:
    
    entry - The entry to feed
    
    iter - The lines iterator
    
    operation - The change operation (add, modify, delete, moddn or modrdn)
    
    Throws:
    
    LdapException - If the change operation is invalid
  - parseEntry
```
protected LdifEntry parseEntry()
                        throws LdapException
```
    Parse a ldif file. The following rules are processed :
```
 <ldif-file> ::= <ldif-attrval-record> <ldif-attrval-records> |
     <ldif-change-record> <ldif-change-records>
 <ldif-attrval-record> ::= <dn-spec> <sep> <attrval-spec> <attrval-specs>
 <ldif-change-record> ::= <dn-spec> <sep> <controls-e> <changerecord>
 <dn-spec> ::= "dn:" <fill> <distinguishedName> | "dn::" <fill> <base64-distinguishedName>
 <changerecord> ::= "changetype:" <fill> <change-op>
 
```
    Returns:
    
    the parsed ldifEntry
    
    Throws:
    
    LdapException - If the ldif file does not contain a valid entry
  - parseVersion
```
protected int parseVersion()
                    throws LdapLdifException
```
    Parse the version from the ldif input.
    
    Returns:
    
    A number representing the version (default to 1)
    
    Throws:
    
    LdapLdifException - If the version is incorrect or if the input is incorrect
  - getLine
```
protected String getLine()
                  throws IOException
```
    gets a line from the underlying data store
    
    Returns:
    
    a line of characters or null if EOF reached
    
    Throws:
    
    IOException - on read failure
  - readLines
```
protected void readLines()
                  throws LdapLdifException
```
    Reads an entry in a ldif buffer, and returns the resulting lines, without comments, and unfolded. The lines represent *one* entry.
    
    Throws:
    
    LdapLdifException - If something went wrong
  - parseLdifFile
```
public List<LdifEntry> parseLdifFile(String fileName)
                              throws LdapLdifException
```
    Parse a ldif file (using the default encoding).
    
    Parameters:
    
    fileName - The ldif file
    
    Returns:
    
    A list of entries
    
    Throws:
    
    LdapLdifException - If the parsing fails
  - parseLdifFile
```
public List<LdifEntry> parseLdifFile(String fileName,
                                     String encoding)
                              throws LdapLdifException
```
    Parse a ldif file, decoding it using the given charset encoding
    
    Parameters:
    
    fileName - The ldif file
    
    encoding - The charset encoding to use
    
    Returns:
    
    A list of entries
    
    Throws:
    
    LdapLdifException - If the parsing fails
  - parseLdif
```
public List<LdifEntry> parseLdif(String ldif)
                          throws LdapLdifException
```
    A method which parses a ldif string and returns a list of entries.
    
    Parameters:
    
    ldif - The ldif string
    
    Returns:
    
    A list of entries, or an empty List
    
    Throws:
    
    LdapLdifException - If something went wrong
  - nextInternal
```
private LdifEntry nextInternal()
```
    Gets the next LDIF on the channel.
    
    Returns:
    
    the next LDIF as a String.
  - next
```
public LdifEntry next()
```
    Gets the next LDIF on the channel.
    
    Returns:
    
    the next LDIF as a String.
  - fetch
```
public LdifEntry fetch()
```
    Gets the current entry, but don't move forward.
    
    Returns:
    
    the pre-fetched entry
  - hasNextInternal
```
private boolean hasNextInternal()
```
    Tests to see if another LDIF is on the input channel.
    
    Returns:
    
    true if another LDIF is available false otherwise.
  - hasNext
```
public boolean hasNext()
```
    Tests to see if another LDIF is on the input channel.
    
    Returns:
    
    true if another LDIF is available false otherwise.
  - removeInternal
```
private void removeInternal()
```
    Always throws UnsupportedOperationException!
    
    See Also:
    
    Iterator.remove()
  - remove
```
public void remove()
```
    Always throws UnsupportedOperationException!
    
    See Also:
    
    Iterator.remove()
  - iterator
```
public Iterator<LdifEntry> iterator()
```
    Specified by:
    
    iterator in interface Iterable<LdifEntry>
    
    Returns:
    
    An iterator on the file
  - hasError
```
public boolean hasError()
```
    Returns:
    
    True if an error occurred during parsing
  - getError
```
public Exception getError()
```
    Returns:
    
    The exception that occurs during an entry parsing
  - parseLdif
```
public List<LdifEntry> parseLdif(BufferedReader reader)
                          throws LdapException
```
    The main entry point of the LdifParser. It reads a buffer and returns a List of entries.
    
    Parameters:
    
    reader - The buffer being processed
    
    Returns:
    
    A list of entries
    
    Throws:
    
    LdapException - If something went wrong
  - containsEntries
```
public boolean containsEntries()
```
    Returns:
    
    True if the ldif file contains entries, fals if it contains changes
  - getLineNumber
```
public int getLineNumber()
```
    Returns:
    
    the current line that is being processed by the reader
  - createLdifEntry
```
protected LdifEntry createLdifEntry(SchemaManager schemaManager)
```
    Creates a schema aware LdifEntry
    
    Parameters:
    
    schemaManager - The SchemaManager
    
    Returns:
    
    an LdifEntry that is schema aware
  - isValidateDn
```
public boolean isValidateDn()
```
    Returns:
    
    true if the DN validation is turned on
  - setValidateDn
```
public void setValidateDn(boolean validateDn)
```
    Turns on/off the DN validation
    
    Parameters:
    
    validateDn - the boolean flag
  - setSchemaManager
```
public void setSchemaManager(SchemaManager schemaManager)
```
    Parameters:
    
    schemaManager - the schemaManager to set
  - close
```
public void close()
           throws IOException
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Throws:
    
    IOException

Class LdifReader

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Field Detail

LOG

lines

position

DEFAULT_VERSION

version

LDIF_ENTRY

CHANGE

UNKNOWN

sizeLimit

SIZE_LIMIT_DEFAULT

MOD_SPEC

ATTRVAL_SPEC

ATTRVAL_SPEC_OR_SEP

prefetched

reader

is

containsEntries

containsChanges

schemaManager

error

entryLen

entryOffset

offset

lineNumber

validateDn

oidCounter

Constructor Detail

LdifReader

LdifReader

LdifReader

LdifReader

LdifReader

LdifReader

LdifReader

Method Detail

initReader

init

getVersion

getSizeLimit

setSizeLimit

parseFill

parseNumber

parseChangeType

parseDn

parseSimpleValue

getValue

parseValue

parseControl

parseAttributeValue

parseAttributeValue

parseModRdn

parseModify

parseChange

parseEntry

parseVersion

getLine

readLines

parseLdifFile

parseLdifFile

parseLdif

nextInternal

next

fetch

hasNextInternal

hasNext

removeInternal

remove

iterator

hasError

getError

parseLdif

containsEntries

getLineNumber