anchor.diff:  
   Registering a serializer that lacks such constructor at the cache manager level will prevent it from being chosen for persistent caches.
   
  -Since copiers only relate to the on-heap store and the latter cannot be made persistent, the above doesn't apply to them.
  -
  -=== Lifecycle: instances vs class names
  +==== Lifecycle: instances vs class names
   
   When a serializer instance is configured using either of
   `CacheConfigurationBuilder.withKeySerializer(Serializer keySerializer)` or `CacheConfigurationBuilder.withValueSerializer(Serializer valueSerializer)`,
   it is up to you to manage the lifecycle of the Serializer instance, ie: dispose of any resource the serializer might hold upon and/or persisting and reloading
   the serializer's state.
   
  -Since copiers only relate to the on-heap store and the latter cannot be made persistent, the above doesn't apply to them.
  -
  -When a serializer or copier class is configured (either at the cache or cache manager level), since Ehcache is responsible for creating the
  -instance, it also is responsible for disposing of it. If a serializer or copier class name is configured and that class implements `java.io.Closeable` then
  +When a serializer class is configured (either at the cache or cache manager level), since Ehcache is responsible for creating the
  +instance, it also is responsible for disposing of it. If a serializer class name is configured and that class implements `java.io.Closeable` then
   `close()` will be called when the cache gets disposed of.
   
  -=== ClassLoaders
  +==== ClassLoaders
   
  -todo.
  +When Ehcache instantiates a serializer itself, it will pass it a `ClassLoader` via the constructor. Such class loader must be used to access the classes
  +of the serialized types as they might not be available in the current class loader
   
  -== Writing your own
  -
  -=== Writing a serializer
  +==== Writing your own serializer
   
   Serializers must act as such, so if you're planning to write your own implementation you have to keep in mind that
   the class of the serialized object MUST be retained after deserialization, ie:
  
positive.code: You can optionally implement `java.io.Closeable`. If you do, Ehcache will call `close()` when a cache using such serializer gets disposed of, but *only if*
  Ehcache instantiated the serializer itself.
  
  === Writing a Copier
  
  Implement the following class:
  
  
negative.code: Serializers are scoped at the cache level: a cache can have a serializer for its keys and another one for its values.
  All stores of a cache will be using and sharing the same key and value serializer pair.
  
  ==== How is a serializer configured?
  
  There are two places where serializers can be configured:
  
  