content/api/user-guide/6.12-entry.mdtext - directory-site - Git at Google

 Title: 6.12 - Entry
 NavPrev: 6.11-dit-structure-rule.html
 NavPrevText: 6.11 - DITStructureRule
 NavUp: 6-ldap-data-structures.html
 NavUpText: 6 - LDAP data structures
 NavNext: 6.13-expr-node.html
 NavNextText: 6.13 - ExprNode
 Notice: 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.

 # 6.12 - Entry

 The _Entry_ class is one of the most important ones in the _API_. It describes the base element stored into a *LDAP* server, and it associates a _Dn_ and some _Attributes_.

 We have two kinds of _Entry_ in the _API_, depending on the presence of a _SchemaManager_ in the _Entry_, or not.

 We also provide a few extended classes, like the _ImmutableEntry_, an immutable version of the _Entry_.

 ## What an entry?

 An entry is an object containing a _Dn_ and some _Attributes_. The following schema shows what's inside an _entry_:

 ![](images/entry.png)

 ## Creating an Entry

 We have many ways to create an _Entry_. Basically, an _Entry_ has a _Dn_ and some _Attributes_. It can be schema aware, or not. We provide constructors to allow a user to create the kind of _Entry_ wanted.

 The simplest way to create an _Entry_ is to call the default constructor. The created entry will have no attributes, and no _Dn_. We can also make it schema aware by passing a _SchemaManager_. Here is an example:

     :::Java
     Entry entry = new DefaultEntry();

     // Now set the DN and some attributes
     Entry entry = new DefaultEntry();

     entry.setDn( "dc=example, dc=com" );
     entry.add( "objectClass", "top", "domain" );
     entry.add( "dc", "example" );

     // Schema aware entry
     Entry entry2 = new DefaultEntry( schemaManager);

     entry2.add( "objectClass", "top", "domain" );
     entry2.add( "dc", "example" );


 You can also create an _Entry_ passing a _Dn_, but no attribute. We can create schema aware entries this way too, passing a _SchemaManager_.

     :::Java
     Dn dn = new Dn( schemaManager, "DomainComponent=example, dc=COM" );
     Entry entry = new DefaultEntry( "dc=example, dc=com" );

     entry.add( "objectClass", "top", "domain" );
     entry.add( "dc", "example" );

     Entry entry2 = new DefaultEntry( schemaManager, "dc=example, dc=com" );

     entry2.add( "objectClass", "top", "domain" );
     entry2.add( "dc", "example" );
     ...

 We can also create an entry by copying an existing entry. The created _Entry_ must be schema aware. Here is an example:

     :::Java
     Entry entry = new DefaultEntry( schemaManager, "dc=example, dc=com" );

     entry2.add( "objectClass", "top", "domain" );
     entry2.add( "dc", "example" );

     Entry entry2 = new DefaultEntry( schemaManager, entry );

     assertEquals( entry.getDn(), entry2.getDn() );

     entry.clear();

 Last, but not least, it's possible to create an _Entry_ using a list of LDIF formated attributes. An example worth ten lines of documentation, so let's see what it means.

 First, we will create a schema agnostic entry:

     :::Java
     Entry entry = new DefaultEntry(
         "dc=example, dc=com",
         "objectClass: top",
         "objectClass: domain",
         "dc: example"
         );

 We can also provide a complete LDIF file (except that we can't add the _dn_):

     :::Java
     String ldif =
         "objectClass: top\n" +           // The \n is mandatory.
         "objectClass: domain\n" +
         "dc: example";

     Entry entry = new DefaultEntry( "dc=example, dc=com", ldif );


 One can also combine LDIF and variables like in this example (note that if you use a variable, the attribute must not be followed by the *':'* char):

     :::Java
     String domain = "example";

     Entry entry = new DefaultEntry(
         "dc=example, dc=com",
         "objectClass: top",
         "objectClass: domain",
         "cc", domain             // No ':'
         );

 All in all, the following constructors are available :

 * DefaultEntry() : Default constructor
 * DefaultEntry(SchemaManager) : Default constructor for a schema aware entry
 * DefaultEntry(String) : Creates an entry with a DN as a String
 * DefaultEntry(SchemaManager, String) : Creates a schema aware entry with a DN as a String
 * DefaultEntry(Dn) : Creates an entry with a DN
 * DefaultEntry(SchemaManager, Dn) : Creates a schema aware entry with a DN as a String
 * DefaultEntry(Dn, Object...) : Creates an entry with a DN and some attributes
 * DefaultEntry(SchemaManager, String, Object...) : Creates a schema aware entry with a DN as a String, and some attributes
 * DefaultEntry(SchemaManager, Dn, Object...) : Creates a schema aware entry with a DN and some attributes
 * DefaultEntry(SchemaManager, Entry) : Creates an entry using a copy of another entry

 ## Modifying an Entry

 We have six methods available that modify the _Entry_ content : _add_, _clear_, _put_, _remove_, _removeAttribute_ and _setDn_. We will review six four methods in the following paragraphs.

 ### Adding Attributes

 Two methods can be used to add attribute into an _Entry_. The first one will add a completed _Attribute_, the second one will add some values into an existing _Attribute_.

 In any case, we can add either an empty attribute, or an attribute with some values. Those values can be _Strings_, _byte[]_ or _Values_. The added attributes can be schema aware, and we can also provide a user provided name for the attribute type.

 ##### add() methods

 The first method makes it possible to add some existing _Attribute_ to an _Entry_. Let's see how it works:

     :::Java
     Attribute cn = new DefaultAttribute( "cn", "test" );
     Attribute cn2 = new DefaultAttribute( "cn", "test2" );

     Entry entry = new DefaultEntry(
         "dc=example, dc=com",
         "objectClass: top",
         "objectClass: person",
         "sn: test" );

     // Add the new attribute
     entry.add( cn );

     // Try to add a second value
     entry.add( cn2 );


 Otherwise, we can add a new attribute and values into the _Entry_ by passing both parameters. We can also pass an _AttributeType_ to the _add()_ method, making the added attribute schema aware. Note that if the _Entry_ itself is already schema aware, this is not necessary.

 Here are some examples, the first one with a schema aware _Entry_, the second one with a schema agnostic _Entry_:

 For a schema aware entry :

     :::Java
     Entry entry = new DefaultEntry(
         schemaManager,
         "dc=example, dc=com",
         "objectClass: top",
         "objectClass: person",
         "sn: test" );

     // Add the new attribute
     entry.add( "cn", "test" );

     // Try to add a second value
     entry.add( "cn", "A  second test   " );

     // We can also add a value to an existing Attribute
     entry.add( "sn", "Another SN" );

     // And even add many values in one shot
     entry.add( "cn", "value1", "value2" );


 For a schema agnostic entry :

     :::Java
     Entry entry = new DefaultEntry(
         "dc=example, dc=com",
         "objectClass: top",
         "objectClass: person",
         "sn: test" );

     // Add the new attribute
     entry.add( "cn", "test" );

     // Try to add a second value
     entry.add( "cn", "A  second  test" );


 As you can see, there is no real difference between those two methods, except that we pass the _schemaManager_ into the first one.


 ##### put() methods

 The big difference with the _add_ method is that the attribute is not added, it will replace an existing one. let's see with an example :

     :::Java
     Entry entry = new DefaultEntry(
         schemaManager,
         "dc=example, dc=com",
         "objectClass: top",
         "objectClass: person",
         "sn: test" );

     // Add the new attribute
     entry.put( "cn", "test" );

     // Try to add a second value : the 'cn' attribute will now contain only 'test2'
     entry.put( "cn", "test2" );

 ### Removing Attributes

 We can remove either an attribute having a specific value, or an entire attribute. In order to remove a complete attribute, you just have to provide the attribute's name, and use the _removeAttributes_ method.

 Here are examples for both usages :

     :::Java
     Entry entry = new DefaultEntry(
         schemaManager,
         "dc=example, dc=com",
         "objectClass: top",
         "objectClass: person",
         "sn: test",
         "cn: test1",
         "cn: test2",
         "cn: test3" );

     // Remove the "test2" value
     entry.remove( "cn", "test2" );

     // Try to remove the full attribute
     entry.removeAttributes( "cn" );

 ### Storing a Dn

 It's also possible to store a new _Dn_ into the Entry, using the _setDn() method. It will replace an existing _Dn_ This method takes either a _Dn_ instance, or a _String_ representing a valid _Dn_.


 ### Clearing the Entry

 You can remove all the _Attribute_s from the entry, using the _clear()_ method :

     :::Java
     Entry entry = new DefaultEntry(
         schemaManager,
         "dc=example, dc=com",
         "objectClass: top",
         "objectClass: person",
         "sn: test",
         "cn: test1",
         "cn: test2",
         "cn: test3" );

     // Remove all the attributes
     entry.clear();

 The _Dn_ will still be around though.

 ## Attribute data access methods

 The *API* provides convenient methods to access the _Entry_ content, and to check if it contains some attributes or some values. We will show these methods in the paragraphs that follow.

 ### Contains method

 The _contains_ and _containsAttributes_ methods check that the _Entry_ contains _Attributes_ and _values_.

 One can check for the existence of a specific value for a given attribute, or even for multiple values for a specific attribute. Let's see the _contains_ method in action:

     :::Java
     Entry entry = new DefaultEntry(
         schemaManager,
         "dc=example, dc=com",
         "objectClass: top",
         "objectClass: person",
         "sn: test",
         "cn: test1",
         "cn: test2",
         "cn: test3" );

     // Check that the entry contains the 'cn' and 'sn' Attributes
     boolean contains = entry.containsAttribute( "cn", "sn" );

     // Check that the entry contains 3 given values of the 'cn' Attribute
     contains = entry.contains( "cn", "test1", "test2", "test3" );

 Note that if one value does not exist, the _contains() method will return false.

 ### getAttributes() and get() methods

 Returns the _Attribute_ having the given name if it exists. The following test demonstrates its usage:

     :::Java
     Entry entry = new DefaultEntry(
         schemaManager,
         "dc=example, dc=com",
         "objectClass: top",
         "objectClass: person",
         "sn: test",
         "cn: test1",
         "cn: test2",
         "cn: test3" );

     // Get the 'cn' Attribute
     Attribute cn = entry.get( "cn" );

     // Get all the Attributes
     Collection<Attribute> attributes = entry.getAttributes();


 ### getDn()

 This method returns the _Entry_'s _Dn_.

 ### hasObjectClass methods

 The _hasObjectClass()_ methods are used to discover if an _Entry_ has a specific _ObjectClass_. This is a convenient method, as it's possible to do the same thing with a _contains()_ call, but with one less parameter (you don't have to provide the _"ObjectClass"_ as a first parameter).

 Here is an example using the two existing methods:

     :::Java
     Entry entry = new DefaultEntry(
         schemaManager,
         "cn=example, dc=com",
         "objectClass: top",
         "objectClass: person",
         "cn: example",
         "sn: test"
         );

     // Test the presence
     boolean isPresent = entry.hasObjectClass( "person", " TOP " );

 As for the _contains()_ method, it will return true if and only if all the ObjectClasses are present in the _entry_.

 Obviously, dealing with a schema agnostic _Entry_, those methods are more strict. You have to use the exact ObjectClasses case sensitive trimmed names (in the previous example, we can use upper cased names, even with spaces around the names).

 Also note that the _hasObjectClass_ method used with _AttributeType_ does not work on a schema agnostic entry.

 ## Miscellaneous methods

 We also have some other methods which can be used on an _Entry_. Here is a list of those methods.

 #### clone()

 Creates a copy of the current _Entry_. All the _Attributes_ are also cloned.

 #### iterator()

 Allows an iteration over all the _Attributes_. The following examples shows how this can be used:

     :::Java
     @Test
     Entry entry = new DefaultEntry(
         "cn=example, dc=com",
         "objectClass: top",
         "objectClass: person",
         "cn: example",
         "sn: test"
         );

     for ( Attribute attribute : entry )
     {
         System.out.println( "Attribute : \n" + attribute.toString() );
     }

 This produces the following output:

     :::Java
     Attribute :
         sn: test

     Attribute :
         cn: example

     Attribute :
         objectclass: top
         objectclass: person

 Note that the _Attribute_ order is not guaranteed.

 #### isSchemaAware()

 Tells if the ¨_Entry_ has an associated _SchemaManager_.

 #### size()

 Returns the number of _Attribute_ stored in the _Entry_.

 #### equals(Object)

 Check if two *Entries* are equal or not. It's important to understand that depending on whether the entry is schema aware or not, the comparison will be processed differently. Typically, the attribute's name must be equivilent after being trimmed and set to lowercase.  If the entry is not schema aware, and we can't compare an attribute named 'cn' with another one named '2.5.4.3' in this case (the _Entry_ must be schema aware to allow such comparison). More important, the values *must* be identical (same casing, same spaces) in this case.
 The attribute's values order is irrelevant.

 Here are one example with a schema agnostic _Entry_:

     :::Java
     Entry entry = new DefaultEntry(
         "dc=example, dc=com",
         "objectClass: top",
         "objectClass: person",
         "sn: test",
         "cn: test1",
         "cn: test2",
         "cn: test3" );

     Entry entry2 = new DefaultEntry(
         "dc=example, dc=com",
         "objectClass: top",
         "objectClass: person",
         "sn: test",
         "cn: test2",
         "CN: test1",
         "cn: test3" );

     // Will return true
     boolean result = entry.equals( entry2 );

 and another example with a schema aware _Entry_:

     :::Java
     Entry entry = new DefaultEntry(
         schemaManager,
         "dc=example, dc=com",
         "objectClass: top",
         "objectClass: person",
         "sn: test",
         "cn: test1",
         "cn: test2",
         "cn: test3" );

     Entry entry2 = new DefaultEntry(
         schemaManager,
         "dc=example,dc=com",
         "objectClass: TOP",
         "objectClass: person",
         "sn: Test",
         "cn: Test2",
         "2.5.4.3: test1",
         "CommonName: test3" );

     // Will return true
     boolean result = entry.equals( entry2 );
	Title: 6.12 - Entry
	NavPrev: 6.11-dit-structure-rule.html
	NavPrevText: 6.11 - DITStructureRule
	NavUp: 6-ldap-data-structures.html
	NavUpText: 6 - LDAP data structures
	NavNext: 6.13-expr-node.html
	NavNextText: 6.13 - ExprNode
	Notice: 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.

	# 6.12 - Entry

	The _Entry_ class is one of the most important ones in the _API_. It describes the base element stored into a LDAP server, and it associates a _Dn_ and some _Attributes_.

	We have two kinds of _Entry_ in the _API_, depending on the presence of a _SchemaManager_ in the _Entry_, or not.

	We also provide a few extended classes, like the _ImmutableEntry_, an immutable version of the _Entry_.

	## What an entry?

	An entry is an object containing a _Dn_ and some _Attributes_. The following schema shows what's inside an _entry_:

	![](images/entry.png)

	## Creating an Entry

	We have many ways to create an _Entry_. Basically, an _Entry_ has a _Dn_ and some _Attributes_. It can be schema aware, or not. We provide constructors to allow a user to create the kind of _Entry_ wanted.

	The simplest way to create an _Entry_ is to call the default constructor. The created entry will have no attributes, and no _Dn_. We can also make it schema aware by passing a _SchemaManager_. Here is an example:

	:::Java
	Entry entry = new DefaultEntry();

	// Now set the DN and some attributes
	Entry entry = new DefaultEntry();

	entry.setDn( "dc=example, dc=com" );
	entry.add( "objectClass", "top", "domain" );
	entry.add( "dc", "example" );

	// Schema aware entry
	Entry entry2 = new DefaultEntry( schemaManager);

	entry2.add( "objectClass", "top", "domain" );
	entry2.add( "dc", "example" );


	You can also create an _Entry_ passing a _Dn_, but no attribute. We can create schema aware entries this way too, passing a _SchemaManager_.

	:::Java
	Dn dn = new Dn( schemaManager, "DomainComponent=example, dc=COM" );
	Entry entry = new DefaultEntry( "dc=example, dc=com" );

	entry.add( "objectClass", "top", "domain" );
	entry.add( "dc", "example" );

	Entry entry2 = new DefaultEntry( schemaManager, "dc=example, dc=com" );

	entry2.add( "objectClass", "top", "domain" );
	entry2.add( "dc", "example" );
	...

	We can also create an entry by copying an existing entry. The created _Entry_ must be schema aware. Here is an example:

	:::Java
	Entry entry = new DefaultEntry( schemaManager, "dc=example, dc=com" );

	entry2.add( "objectClass", "top", "domain" );
	entry2.add( "dc", "example" );

	Entry entry2 = new DefaultEntry( schemaManager, entry );

	assertEquals( entry.getDn(), entry2.getDn() );

	entry.clear();

	Last, but not least, it's possible to create an _Entry_ using a list of LDIF formated attributes. An example worth ten lines of documentation, so let's see what it means.

	First, we will create a schema agnostic entry:

	:::Java
	Entry entry = new DefaultEntry(
	"dc=example, dc=com",
	"objectClass: top",
	"objectClass: domain",
	"dc: example"
	);

	We can also provide a complete LDIF file (except that we can't add the _dn_):

	:::Java
	String ldif =
	"objectClass: top\n" + // The \n is mandatory.
	"objectClass: domain\n" +
	"dc: example";

	Entry entry = new DefaultEntry( "dc=example, dc=com", ldif );


	One can also combine LDIF and variables like in this example (note that if you use a variable, the attribute must not be followed by the ':' char):

	:::Java
	String domain = "example";

	Entry entry = new DefaultEntry(
	"dc=example, dc=com",
	"objectClass: top",
	"objectClass: domain",
	"cc", domain // No ':'
	);

	All in all, the following constructors are available :

	* DefaultEntry() : Default constructor
	* DefaultEntry(SchemaManager) : Default constructor for a schema aware entry
	* DefaultEntry(String) : Creates an entry with a DN as a String
	* DefaultEntry(SchemaManager, String) : Creates a schema aware entry with a DN as a String
	* DefaultEntry(Dn) : Creates an entry with a DN
	* DefaultEntry(SchemaManager, Dn) : Creates a schema aware entry with a DN as a String
	* DefaultEntry(Dn, Object...) : Creates an entry with a DN and some attributes
	* DefaultEntry(SchemaManager, String, Object...) : Creates a schema aware entry with a DN as a String, and some attributes
	* DefaultEntry(SchemaManager, Dn, Object...) : Creates a schema aware entry with a DN and some attributes
	* DefaultEntry(SchemaManager, Entry) : Creates an entry using a copy of another entry

	## Modifying an Entry

	We have six methods available that modify the _Entry_ content : _add_, _clear_, _put_, _remove_, _removeAttribute_ and _setDn_. We will review six four methods in the following paragraphs.

	### Adding Attributes

	Two methods can be used to add attribute into an _Entry_. The first one will add a completed _Attribute_, the second one will add some values into an existing _Attribute_.

	In any case, we can add either an empty attribute, or an attribute with some values. Those values can be _Strings_, _byte[]_ or _Values_. The added attributes can be schema aware, and we can also provide a user provided name for the attribute type.

	##### add() methods

	The first method makes it possible to add some existing _Attribute_ to an _Entry_. Let's see how it works:

	:::Java
	Attribute cn = new DefaultAttribute( "cn", "test" );
	Attribute cn2 = new DefaultAttribute( "cn", "test2" );

	Entry entry = new DefaultEntry(
	"dc=example, dc=com",
	"objectClass: top",
	"objectClass: person",
	"sn: test" );

	// Add the new attribute
	entry.add( cn );

	// Try to add a second value
	entry.add( cn2 );


	Otherwise, we can add a new attribute and values into the _Entry_ by passing both parameters. We can also pass an _AttributeType_ to the _add()_ method, making the added attribute schema aware. Note that if the _Entry_ itself is already schema aware, this is not necessary.

	Here are some examples, the first one with a schema aware _Entry_, the second one with a schema agnostic _Entry_:

	For a schema aware entry :

	:::Java
	Entry entry = new DefaultEntry(
	schemaManager,
	"dc=example, dc=com",
	"objectClass: top",
	"objectClass: person",
	"sn: test" );

	// Add the new attribute
	entry.add( "cn", "test" );

	// Try to add a second value
	entry.add( "cn", "A second test " );

	// We can also add a value to an existing Attribute
	entry.add( "sn", "Another SN" );

	// And even add many values in one shot
	entry.add( "cn", "value1", "value2" );



	For a schema agnostic entry :

	:::Java
	Entry entry = new DefaultEntry(
	"dc=example, dc=com",
	"objectClass: top",
	"objectClass: person",
	"sn: test" );

	// Add the new attribute
	entry.add( "cn", "test" );

	// Try to add a second value
	entry.add( "cn", "A second test" );


	As you can see, there is no real difference between those two methods, except that we pass the _schemaManager_ into the first one.


	##### put() methods

	The big difference with the _add_ method is that the attribute is not added, it will replace an existing one. let's see with an example :

	:::Java
	Entry entry = new DefaultEntry(
	schemaManager,
	"dc=example, dc=com",
	"objectClass: top",
	"objectClass: person",
	"sn: test" );

	// Add the new attribute
	entry.put( "cn", "test" );

	// Try to add a second value : the 'cn' attribute will now contain only 'test2'
	entry.put( "cn", "test2" );

	### Removing Attributes

	We can remove either an attribute having a specific value, or an entire attribute. In order to remove a complete attribute, you just have to provide the attribute's name, and use the _removeAttributes_ method.

	Here are examples for both usages :

	:::Java
	Entry entry = new DefaultEntry(
	schemaManager,
	"dc=example, dc=com",
	"objectClass: top",
	"objectClass: person",
	"sn: test",
	"cn: test1",
	"cn: test2",
	"cn: test3" );

	// Remove the "test2" value
	entry.remove( "cn", "test2" );

	// Try to remove the full attribute
	entry.removeAttributes( "cn" );

	### Storing a Dn

	It's also possible to store a new _Dn_ into the Entry, using the _setDn() method. It will replace an existing _Dn_ This method takes either a _Dn_ instance, or a _String_ representing a valid _Dn_.


	### Clearing the Entry

	You can remove all the _Attribute_s from the entry, using the _clear()_ method :

	:::Java
	Entry entry = new DefaultEntry(
	schemaManager,
	"dc=example, dc=com",
	"objectClass: top",
	"objectClass: person",
	"sn: test",
	"cn: test1",
	"cn: test2",
	"cn: test3" );

	// Remove all the attributes
	entry.clear();

	The _Dn_ will still be around though.

	## Attribute data access methods

	The API provides convenient methods to access the _Entry_ content, and to check if it contains some attributes or some values. We will show these methods in the paragraphs that follow.

	### Contains method

	The _contains_ and _containsAttributes_ methods check that the _Entry_ contains _Attributes_ and _values_.

	One can check for the existence of a specific value for a given attribute, or even for multiple values for a specific attribute. Let's see the _contains_ method in action:

	:::Java
	Entry entry = new DefaultEntry(
	schemaManager,
	"dc=example, dc=com",
	"objectClass: top",
	"objectClass: person",
	"sn: test",
	"cn: test1",
	"cn: test2",
	"cn: test3" );

	// Check that the entry contains the 'cn' and 'sn' Attributes
	boolean contains = entry.containsAttribute( "cn", "sn" );

	// Check that the entry contains 3 given values of the 'cn' Attribute
	contains = entry.contains( "cn", "test1", "test2", "test3" );

	Note that if one value does not exist, the _contains() method will return false.

	### getAttributes() and get() methods

	Returns the _Attribute_ having the given name if it exists. The following test demonstrates its usage:

	:::Java
	Entry entry = new DefaultEntry(
	schemaManager,
	"dc=example, dc=com",
	"objectClass: top",
	"objectClass: person",
	"sn: test",
	"cn: test1",
	"cn: test2",
	"cn: test3" );

	// Get the 'cn' Attribute
	Attribute cn = entry.get( "cn" );

	// Get all the Attributes
	Collection<Attribute> attributes = entry.getAttributes();


	### getDn()

	This method returns the _Entry_'s _Dn_.

	### hasObjectClass methods

	The _hasObjectClass()_ methods are used to discover if an _Entry_ has a specific _ObjectClass_. This is a convenient method, as it's possible to do the same thing with a _contains()_ call, but with one less parameter (you don't have to provide the _"ObjectClass"_ as a first parameter).

	Here is an example using the two existing methods:

	:::Java
	Entry entry = new DefaultEntry(
	schemaManager,
	"cn=example, dc=com",
	"objectClass: top",
	"objectClass: person",
	"cn: example",
	"sn: test"
	);

	// Test the presence
	boolean isPresent = entry.hasObjectClass( "person", " TOP " );

	As for the _contains()_ method, it will return true if and only if all the ObjectClasses are present in the _entry_.

	Obviously, dealing with a schema agnostic _Entry_, those methods are more strict. You have to use the exact ObjectClasses case sensitive trimmed names (in the previous example, we can use upper cased names, even with spaces around the names).

	Also note that the _hasObjectClass_ method used with _AttributeType_ does not work on a schema agnostic entry.

	## Miscellaneous methods

	We also have some other methods which can be used on an _Entry_. Here is a list of those methods.

	#### clone()

	Creates a copy of the current _Entry_. All the _Attributes_ are also cloned.

	#### iterator()

	Allows an iteration over all the _Attributes_. The following examples shows how this can be used:

	:::Java
	@Test
	Entry entry = new DefaultEntry(
	"cn=example, dc=com",
	"objectClass: top",
	"objectClass: person",
	"cn: example",
	"sn: test"
	);

	for ( Attribute attribute : entry )
	{
	System.out.println( "Attribute : \n" + attribute.toString() );
	}

	This produces the following output:

	:::Java
	Attribute :
	sn: test

	Attribute :
	cn: example

	Attribute :
	objectclass: top
	objectclass: person

	Note that the _Attribute_ order is not guaranteed.

	#### isSchemaAware()

	Tells if the ¨_Entry_ has an associated _SchemaManager_.

	#### size()

	Returns the number of _Attribute_ stored in the _Entry_.

	#### equals(Object)

	Check if two Entries are equal or not. It's important to understand that depending on whether the entry is schema aware or not, the comparison will be processed differently. Typically, the attribute's name must be equivilent after being trimmed and set to lowercase. If the entry is not schema aware, and we can't compare an attribute named 'cn' with another one named '2.5.4.3' in this case (the _Entry_ must be schema aware to allow such comparison). More important, the values must be identical (same casing, same spaces) in this case.
	The attribute's values order is irrelevant.

	Here are one example with a schema agnostic _Entry_:

	:::Java
	Entry entry = new DefaultEntry(
	"dc=example, dc=com",
	"objectClass: top",
	"objectClass: person",
	"sn: test",
	"cn: test1",
	"cn: test2",
	"cn: test3" );

	Entry entry2 = new DefaultEntry(
	"dc=example, dc=com",
	"objectClass: top",
	"objectClass: person",
	"sn: test",
	"cn: test2",
	"CN: test1",
	"cn: test3" );

	// Will return true
	boolean result = entry.equals( entry2 );

	and another example with a schema aware _Entry_:

	:::Java
	Entry entry = new DefaultEntry(
	schemaManager,
	"dc=example, dc=com",
	"objectClass: top",
	"objectClass: person",
	"sn: test",
	"cn: test1",
	"cn: test2",
	"cn: test3" );

	Entry entry2 = new DefaultEntry(
	schemaManager,
	"dc=example,dc=com",
	"objectClass: TOP",
	"objectClass: person",
	"sn: Test",
	"cn: Test2",
	"2.5.4.3: test1",
	"CommonName: test3" );

	// Will return true
	boolean result = entry.equals( entry2 );