Package io.deephaven.proto.controller

Class SubscribeRequest.Builder

java.lang.Object
com.google.protobuf.AbstractMessageLite.Builder
com.google.protobuf.AbstractMessage.Builder<BuilderT>
com.google.protobuf.GeneratedMessage.Builder<SubscribeRequest.Builder>
io.deephaven.proto.controller.SubscribeRequest.Builder
All Implemented Interfaces:
com.google.protobuf.Message.Builder, com.google.protobuf.MessageLite.Builder, com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder, SubscribeRequestOrBuilder, Cloneable
Enclosing class:
SubscribeRequest
public static final class SubscribeRequest.Builder extends com.google.protobuf.GeneratedMessage.Builder<SubscribeRequest.Builder> implements SubscribeRequestOrBuilder
Protobuf type io.deephaven.proto.controller.SubscribeRequest

  • Method Details

    • getDescriptor

      public static final com.google.protobuf.Descriptors.Descriptor getDescriptor()

    • internalGetFieldAccessorTable

      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable()
      Specified by:
      internalGetFieldAccessorTable in class com.google.protobuf.GeneratedMessage.Builder<SubscribeRequest.Builder>

    • clear

      public SubscribeRequest.Builder clear()
      Specified by:
      clear in interface com.google.protobuf.Message.Builder
      Specified by:
      clear in interface com.google.protobuf.MessageLite.Builder
      Overrides:
      clear in class com.google.protobuf.GeneratedMessage.Builder<SubscribeRequest.Builder>

    • getDescriptorForType

      public com.google.protobuf.Descriptors.Descriptor getDescriptorForType()
      Specified by:
      getDescriptorForType in interface com.google.protobuf.Message.Builder
      Specified by:
      getDescriptorForType in interface com.google.protobuf.MessageOrBuilder
      Overrides:
      getDescriptorForType in class com.google.protobuf.GeneratedMessage.Builder<SubscribeRequest.Builder>

    • getDefaultInstanceForType

      public SubscribeRequest getDefaultInstanceForType()
      Specified by:
      getDefaultInstanceForType in interface com.google.protobuf.MessageLiteOrBuilder
      Specified by:
      getDefaultInstanceForType in interface com.google.protobuf.MessageOrBuilder

    • build

      public SubscribeRequest build()
      Specified by:
      build in interface com.google.protobuf.Message.Builder
      Specified by:
      build in interface com.google.protobuf.MessageLite.Builder

    • buildPartial

      public SubscribeRequest buildPartial()
      Specified by:
      buildPartial in interface com.google.protobuf.Message.Builder
      Specified by:
      buildPartial in interface com.google.protobuf.MessageLite.Builder

    • mergeFrom

      public SubscribeRequest.Builder mergeFrom(com.google.protobuf.Message other)
      Specified by:
      mergeFrom in interface com.google.protobuf.Message.Builder
      Overrides:
      mergeFrom in class com.google.protobuf.AbstractMessage.Builder<SubscribeRequest.Builder>

    • mergeFrom

      public SubscribeRequest.Builder mergeFrom(SubscribeRequest other)

    • isInitialized

      public final boolean isInitialized()
      Specified by:
      isInitialized in interface com.google.protobuf.MessageLiteOrBuilder
      Overrides:
      isInitialized in class com.google.protobuf.GeneratedMessage.Builder<SubscribeRequest.Builder>

    • mergeFrom

      public SubscribeRequest.Builder mergeFrom(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws IOException
      Specified by:
      mergeFrom in interface com.google.protobuf.Message.Builder
      Specified by:
      mergeFrom in interface com.google.protobuf.MessageLite.Builder
      Overrides:
      mergeFrom in class com.google.protobuf.AbstractMessage.Builder<SubscribeRequest.Builder>
      Throws:
      IOException

    • getCookie

      public com.google.protobuf.ByteString getCookie()
      bytes cookie = 1;
      Specified by:
      getCookie in interface SubscribeRequestOrBuilder
      Returns:
      The cookie.

    • setCookie

      public SubscribeRequest.Builder setCookie(com.google.protobuf.ByteString value)
      bytes cookie = 1;
      Parameters:
      value - The cookie to set.
      Returns:
      This builder for chaining.

    • clearCookie

      public SubscribeRequest.Builder clearCookie()
      bytes cookie = 1;
      Returns:
      This builder for chaining.

    • getFiltersList

      public List<SubscriptionFilter> getFiltersList()
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;
      Specified by:
      getFiltersList in interface SubscribeRequestOrBuilder

    • getFiltersCount

      public int getFiltersCount()
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;
      Specified by:
      getFiltersCount in interface SubscribeRequestOrBuilder

    • getFilters

      public SubscriptionFilter getFilters(int index)
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;
      Specified by:
      getFilters in interface SubscribeRequestOrBuilder

    • setFilters

      public SubscribeRequest.Builder setFilters(int index, SubscriptionFilter value)
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;

    • setFilters

      public SubscribeRequest.Builder setFilters(int index, SubscriptionFilter.Builder builderForValue)
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;

    • addFilters

      public SubscribeRequest.Builder addFilters(SubscriptionFilter value)
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;

    • addFilters

      public SubscribeRequest.Builder addFilters(int index, SubscriptionFilter value)
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;

    • addFilters

      public SubscribeRequest.Builder addFilters(SubscriptionFilter.Builder builderForValue)
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;

    • addFilters

      public SubscribeRequest.Builder addFilters(int index, SubscriptionFilter.Builder builderForValue)
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;

    • addAllFilters

      public SubscribeRequest.Builder addAllFilters(Iterable<? extends SubscriptionFilter> values)
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;

    • clearFilters

      public SubscribeRequest.Builder clearFilters()
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;

    • removeFilters

      public SubscribeRequest.Builder removeFilters(int index)
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;

    • getFiltersBuilder

      public SubscriptionFilter.Builder getFiltersBuilder(int index)
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;

    • getFiltersOrBuilder

      public SubscriptionFilterOrBuilder getFiltersOrBuilder(int index)
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;
      Specified by:
      getFiltersOrBuilder in interface SubscribeRequestOrBuilder

    • getFiltersOrBuilderList

      public List<? extends SubscriptionFilterOrBuilder> getFiltersOrBuilderList()
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;
      Specified by:
      getFiltersOrBuilderList in interface SubscribeRequestOrBuilder

    • addFiltersBuilder

      public SubscriptionFilter.Builder addFiltersBuilder()
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;

    • addFiltersBuilder

      public SubscriptionFilter.Builder addFiltersBuilder(int index)
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;

    • getFiltersBuilderList

      public List<SubscriptionFilter.Builder> getFiltersBuilderList()
       Optional set of filters narrowing the subscription to a subset of the PQs
 the client is otherwise allowed to see. Semantics:

 - An empty list (the default) means "no filter": the subscription behaves
 as it did before this field was added and the client receives events for
 every PQ visible to it.
 - A non-empty list is OR-combined: a PQ matches the filter iff at least
 one element in the list matches it.
 - The visibility/ACL check is always implied, the filter can only
 further narrow the set; it can never widen visibility.
 - Filtering applies only to PQ-scoped events (SE_PUT and SE_REMOVE).
 SE_CONFIG_UPDATE and SE_BATCH_END are control/global events and are
 always delivered regardless of the filter.
 - The filter is re-evaluated on every PQ change. A PQ that transitions
 into the matching set (e.g. via rename or owner change when filtering
 by owner and name) is delivered as SE_PUT; a PQ that transitions out is
 delivered as SE_REMOVE. Servers track which serials have been delivered
 to a given subscription so that these enter/leave transitions are
 emitted exactly once.
 - Malformed filter elements (see SubscriptionFilter) MUST cause the RPC
 to fail with INVALID_ARGUMENT on servers that honor this field.

 Backwards-compatibility contract: a server MAY ignore this field (e.g. an
 older server that predates filter support, where the unknown field is
 silently dropped by proto3 parsing). Clients therefore MUST be prepared to
 apply the same filter locally to the incoming stream to guarantee correct
 behavior, including synthesizing the same enter/leave SE_PUT and SE_REMOVE
 transitions described above against a fully unfiltered stream.
      repeated .io.deephaven.proto.controller.SubscriptionFilter filters = 2;