anchor.diff:  properties of the proto schema.
   
   Query builds upon the proto definitions you can configure when setting up the `ProtoStreamMarshaller`.
  -Make sure to configure this marshaller before attempting querying. Once this is completed
  -you must add another optional depdency: `infinispan-query-dsl` to start using queries.
  -
  -You can do this by adding the following dependency to your project.
  -
  -[source,xml]
  -----
  -<dependency>
  -    <groupId>org.infinispan</groupId>
  -    <artifactId>infinispan-query-dsl</artifactId>
  -</dependency>
  -----
  -
  -With this added you can use Infinispan querying just as you would normally, nothing special required.
  +Either method of Serialization above will automatically register the schema with the server at
  +startup, meaning that you will automatically gain the ability to query objects stored in the
  +remote Infinispan Server.
  +
   You can read more about this at https://infinispan.org/docs/dev/user_guide/user_guide.html#query_dsl.
   
   You can use either the Query DSL or the Ickle Query language with the Quarkus Infinispan client
  
positive.code: | Property
  | Default Value
  | Description
  
  | `quarkus.infinispan-client.server-list`
  | <empty>
  | Defines the list of servers to connect to upon startup. This allows for multiple servers separated by a semicolon
  for each. (eg. host1:11222;host:11222)
  
  | `quarkus.infinispan-client.near-cache-max-entries`
  | 0
  
negative.code: }
  ----
  
  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
  