anchor.diff:  
       @PreDestroy
       public void release() {
  -        // clean and release any resources
  +        // Cleans and releases any resource
       }
   }
   ----
  -Let's walk thought the implementation of the `Producer` annotated method.
  -
  -We start by checking if the map iterator was already initialized and if not we get the map by it's name and we initialize it.
  -we do that in the `@Producer` method to ensure the map is only initialized if the `next()` method is called (a lazy initialisation). we also avoid the
  -map initialization in the `PostConstruct` as the hazelcast map is not serializable.
  -
  -IMPORTANT: Note that all the objects initialized in the `PostConstruct` method needs to be serializable as the source
  -may be serialized and sent to an other worker in a distributed cluster for it's execution.
  -
  -From the map, we create an iterator on the map keys that we will use to read from the map. then we will transform every pair
  -of key/value to a Talend Record with a key, value Object on every call to next.
  -
  -Notice here that we have used the `RecordBuilderFactory` class which is a built in service in TCK that we have injected via
  -the Source constructor. This service is a factory to create Talend Records.
  -
  -Now the `next()` method will produce a Record every time it's called. the method will return null if no more data is in the map.
  -
  -____
  -That's all for the `@Producer` annotated method.
  -
  -Now let's implement the `@PreDestroy` annotated method which will be responsible of releasing
  -all the resource used by the Source. So here we will need to shutdown the hazelcast client instance to release any connection
  -between the component and hazelcast cluster.
  -____
  +The `Producer` implements the following logic:
  +* Check if the map iterator is already initialized. If not, get the map from its name and initialize the map iterator. This is done in the `@Producer` method to ensure the map is initialized only if the `next()` method is called (lazy initialization). It also avoids the map initialization in the `PostConstruct` method as the Hazelcast map is not serializable.
  ++
  +IMPORTANT: All the objects initialized in the `PostConstruct` method need to be serializable as the source can be serialized and sent to another worker in a distributed cluster.
  ++
  +* From the map, create an iterator on the map keys that will read from the map. 
  +* Transform every key/value pair into a Talend Record with a "key, value" object on every call to `next()`.
  ++
  +NOTE: The `RecordBuilderFactory` class used above is a built-in service in TCK injected via the Source constructor. This service is a factory to create Talend Records.
  +* Now, the `next()` method will produce a Record every time it is called. The method will return "null" if there is no more data in the map.
  ++
  +. Implement the `@PreDestroy` annotated method, responsible for releasing
  +all resources used by the Source. The method needs to shut the Hazelcast client instance down to release any connection between the component and the Hazelcast cluster.
  ++
   [source,java,indent=0,subs="verbatim,quotes,attributes"]
   ----
   package org.talend.components.hazelcast;
  
positive.code:         dataset.setConnection(connection);
          dataset.setMapName(MAP_NAME);
  
          final String configUri = configurationByExample().forInstance(dataset).configured().toQueryString();
  
          Job.components()
                  .component("Input", "Hazelcast://Input?" + configUri)
  
negative.code: 
  import java.io.Serializable;
  
  @GridLayout({ <1>
          @GridLayout.Row("clusterIpAddress"),
          @GridLayout.Row({"groupName", "password"})
  })
  @DataStore("HazelcastDatastore") <2>
  @Documentation("Hazelcast Datastore configuration") <3>
  public class HazelcastDatastore implements Serializable {
  
      @Option <4>
      @Required <5>
      @Documentation("The hazelcast cluster ip address")
      private String clusterIpAddress;
  
  