anchor.diff:  }
   ----
   
  -The default serialization is done using a library based on protobuf. We need to define the proto
  -buf schema and a marshaller for each user type(s).
  -
  -NOTE: Annotation based proto stream marshalling is not yet supported in
  -the Quarkus Infinispan client. This will be added soon, allowing you to only annotate your classes,
  -skipping the following steps.
  -
  -NOTE: This version has an issue currently requiring the Query DSL module as a dependency when running in
  -native mode with proto buf based marshalling. This should be remedied in a future version.
  +Serialization of user types uses a library based on protobuf, called Protostream.
  +
  +=== Annotation based Serialization
  +
  +This can be done automatically by adding protostream annotations to your user classes.
  +In addition a single Initializer annotated interface is required which controls how
  +the supporting classes are generated.
  +
  +Here is an example of how the preceding classes should be changed:
  +
  +.Author.java
  +[source,java]
  +----
  +    @ProtoFactory
  +    public Author(String name, String surname) {
  +        this.name = Objects.requireNonNull(name);
  +        this.surname = Objects.requireNonNull(surname);
  +    }
  +
  +    @ProtoField(number = 1)
  +    public String getName() {
  +        return name;
  +    }
  +
  +    @ProtoField(number = 2)
  +    public String getSurname() {
  +        return surname;
  +    }
  +----
  +
  +.Book.java
  +[source,java]
  +----
  +    @ProtoFactory
  +    public Book(String title, String description, int publicationYear, Set<Author> authors) {
  +        this.title = Objects.requireNonNull(title);
  +        this.description = Objects.requireNonNull(description);
  +        this.publicationYear = publicationYear;
  +        this.authors = Objects.requireNonNull(authors);
  +    }
  +
  +    @ProtoField(number = 1)
  +    public String getTitle() {
  +        return title;
  +    }
  +
  +    @ProtoField(number = 2)
  +    public String getDescription() {
  +        return description;
  +    }
  +
  +    @ProtoField(number = 3, defaultValue = "-1")
  +    public int getPublicationYear() {
  +        return publicationYear;
  +    }
  +
  +    @ProtoField(number = 4)
  +    public Set<Author> getAuthors() {
  +        return authors;
  +    }
  +----
  +If your classes have only mutable fields, then the `ProtoFactory` annotation
  +is not required, assuming your class has a no arg constructor.
  +
  +Then all that is required is a very simple `SerializationContextInitializer` interface with an annotation
  +on it to specify configuration settings
  +
  +.BookContextInitializer.java
  +[source,java]
  +----
  +@AutoProtoSchemaBuilder(includeClasses = { Book.class, Author.class }, schemaPackageName = "book_sample")
  +interface BookContextInitializer extends SerializationContextInitializer {
  +}
  +----
  +
  +So in this case we will automatically generate the marshaller and schemas for the included classes and
  +place them in the schema package automatically. The package does not have to be provided, but if you
  +utilize querying, you must know the generated package.
  +
  +NOTE: In Quarkus the `schemaFileName` and `schemaFilePath` attributes should NOT be set on the `AutoProtoSchemaBuilder` annotation, setting either will cause native runtime to error.
  +
  +=== User written serialization
  +
  +The previous method is suggested for any case when the user can annotate their classes.
  +Unfortunately the user may not be able to annotate all classes they will put in the
  +cache. In this case you must define your schema and create your own Marshaller(s)
  +yourself.
   
   Protobuf schema:: You can supply a protobuf schema through either one of two ways.
     . Proto File
  
positive.code:       return new BookMarshaller();
     }
  ----
  
  NOTE: Annotation based proto stream marshalling is not yet supported in
  the Quarkus Infinispan client.
  
  === Providing your own Marshaller
  
  You can implement the `org.infinispan.commons.marshaller.Marshaller` interface. This will allow you
  to put keys and values of the types it supports directly with the client. All that is required is to have your
  class available in classpath and configure the property value to be the fully qualified class name. This
  method does not require any optional dependencies.
  
  It is recommended to extend from the `org.infinispan.commons.marshall.AbstractMarshaller` class to reduce
  the lines of the class. Here is an example of a Marshaller implementation for String instances.
  
  With that class in your project/classpath, all you need to do is add the following to your
  hotrod-client.properties as mentioned above.
  
  [source,properties]
  infinispan.client.hotrod.marshaller=com.example.MyMarshaller
  
  Note that the Marshaller implementation must have a no arg constructor or static factory method named
  `getInstance`.
  
  == Dependency Injection
  
  
negative.code: If this value is zero or less near cache is disabled. A value greater than zero enables near
  cache and only that many entries will be held a time, removing older entries to save memory
  (per cache).
  | Build time only / Requires compilation to change
  
  |===
  
  It is also possible to configure a `hotrod-client.properties` as described in the Infinispan user guide. Note that
  the `hotrod-client.properties` values overwrite any matching property from the other configuration values (eg. near cache).
  This properties file is build time only and if it is changed, requires a full rebuild.
  
  == Serialization (Key Value types support)
  
  