grpc.cache_client.CacheclientGrpcKt.kt Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of client-protos-jvm Show documentation
Show all versions of client-protos-jvm Show documentation
Kotlin protobuf protocols for the JVM that define the Momento gRPC wire format
package grpc.cache_client
import grpc.cache_client.ScsGrpc.getServiceDescriptor
import io.grpc.CallOptions
import io.grpc.CallOptions.DEFAULT
import io.grpc.Channel
import io.grpc.Metadata
import io.grpc.MethodDescriptor
import io.grpc.ServerServiceDefinition
import io.grpc.ServerServiceDefinition.builder
import io.grpc.ServiceDescriptor
import io.grpc.Status.UNIMPLEMENTED
import io.grpc.StatusException
import io.grpc.kotlin.AbstractCoroutineServerImpl
import io.grpc.kotlin.AbstractCoroutineStub
import io.grpc.kotlin.ClientCalls.serverStreamingRpc
import io.grpc.kotlin.ClientCalls.unaryRpc
import io.grpc.kotlin.ServerCalls.serverStreamingServerMethodDefinition
import io.grpc.kotlin.ServerCalls.unaryServerMethodDefinition
import io.grpc.kotlin.StubFor
import kotlin.Deprecated
import kotlin.String
import kotlin.coroutines.CoroutineContext
import kotlin.coroutines.EmptyCoroutineContext
import kotlin.jvm.JvmOverloads
import kotlin.jvm.JvmStatic
import kotlinx.coroutines.flow.Flow
/**
* Holder for Kotlin coroutine-based client and server APIs for cache_client.Scs.
*/
public object ScsGrpcKt {
public const val SERVICE_NAME: String = ScsGrpc.SERVICE_NAME
@JvmStatic
public val serviceDescriptor: ServiceDescriptor
get() = getServiceDescriptor()
public val getMethod: MethodDescriptor<_GetRequest, _GetResponse>
@JvmStatic
get() = ScsGrpc.getGetMethod()
public val getBatchMethod: MethodDescriptor<_GetBatchRequest, _GetResponse>
@JvmStatic
get() = ScsGrpc.getGetBatchMethod()
public val setMethod: MethodDescriptor<_SetRequest, _SetResponse>
@JvmStatic
get() = ScsGrpc.getSetMethod()
public val setBatchMethod: MethodDescriptor<_SetBatchRequest, _SetResponse>
@JvmStatic
get() = ScsGrpc.getSetBatchMethod()
public val setIfMethod: MethodDescriptor<_SetIfRequest, _SetIfResponse>
@JvmStatic
get() = ScsGrpc.getSetIfMethod()
public val setIfNotExistsMethod: MethodDescriptor<_SetIfNotExistsRequest, _SetIfNotExistsResponse>
@JvmStatic
get() = ScsGrpc.getSetIfNotExistsMethod()
public val deleteMethod: MethodDescriptor<_DeleteRequest, _DeleteResponse>
@JvmStatic
get() = ScsGrpc.getDeleteMethod()
public val keysExistMethod: MethodDescriptor<_KeysExistRequest, _KeysExistResponse>
@JvmStatic
get() = ScsGrpc.getKeysExistMethod()
public val incrementMethod: MethodDescriptor<_IncrementRequest, _IncrementResponse>
@JvmStatic
get() = ScsGrpc.getIncrementMethod()
public val updateTtlMethod: MethodDescriptor<_UpdateTtlRequest, _UpdateTtlResponse>
@JvmStatic
get() = ScsGrpc.getUpdateTtlMethod()
public val itemGetTtlMethod: MethodDescriptor<_ItemGetTtlRequest, _ItemGetTtlResponse>
@JvmStatic
get() = ScsGrpc.getItemGetTtlMethod()
public val itemGetTypeMethod: MethodDescriptor<_ItemGetTypeRequest, _ItemGetTypeResponse>
@JvmStatic
get() = ScsGrpc.getItemGetTypeMethod()
public val dictionaryGetMethod: MethodDescriptor<_DictionaryGetRequest, _DictionaryGetResponse>
@JvmStatic
get() = ScsGrpc.getDictionaryGetMethod()
public val dictionaryFetchMethod:
MethodDescriptor<_DictionaryFetchRequest, _DictionaryFetchResponse>
@JvmStatic
get() = ScsGrpc.getDictionaryFetchMethod()
public val dictionarySetMethod: MethodDescriptor<_DictionarySetRequest, _DictionarySetResponse>
@JvmStatic
get() = ScsGrpc.getDictionarySetMethod()
public val dictionaryIncrementMethod:
MethodDescriptor<_DictionaryIncrementRequest, _DictionaryIncrementResponse>
@JvmStatic
get() = ScsGrpc.getDictionaryIncrementMethod()
public val dictionaryDeleteMethod:
MethodDescriptor<_DictionaryDeleteRequest, _DictionaryDeleteResponse>
@JvmStatic
get() = ScsGrpc.getDictionaryDeleteMethod()
public val dictionaryLengthMethod:
MethodDescriptor<_DictionaryLengthRequest, _DictionaryLengthResponse>
@JvmStatic
get() = ScsGrpc.getDictionaryLengthMethod()
public val setFetchMethod: MethodDescriptor<_SetFetchRequest, _SetFetchResponse>
@JvmStatic
get() = ScsGrpc.getSetFetchMethod()
public val setSampleMethod: MethodDescriptor<_SetSampleRequest, _SetSampleResponse>
@JvmStatic
get() = ScsGrpc.getSetSampleMethod()
public val setUnionMethod: MethodDescriptor<_SetUnionRequest, _SetUnionResponse>
@JvmStatic
get() = ScsGrpc.getSetUnionMethod()
public val setDifferenceMethod: MethodDescriptor<_SetDifferenceRequest, _SetDifferenceResponse>
@JvmStatic
get() = ScsGrpc.getSetDifferenceMethod()
public val setContainsMethod: MethodDescriptor<_SetContainsRequest, _SetContainsResponse>
@JvmStatic
get() = ScsGrpc.getSetContainsMethod()
public val setLengthMethod: MethodDescriptor<_SetLengthRequest, _SetLengthResponse>
@JvmStatic
get() = ScsGrpc.getSetLengthMethod()
public val setPopMethod: MethodDescriptor<_SetPopRequest, _SetPopResponse>
@JvmStatic
get() = ScsGrpc.getSetPopMethod()
public val listPushFrontMethod: MethodDescriptor<_ListPushFrontRequest, _ListPushFrontResponse>
@JvmStatic
get() = ScsGrpc.getListPushFrontMethod()
public val listPushBackMethod: MethodDescriptor<_ListPushBackRequest, _ListPushBackResponse>
@JvmStatic
get() = ScsGrpc.getListPushBackMethod()
public val listPopFrontMethod: MethodDescriptor<_ListPopFrontRequest, _ListPopFrontResponse>
@JvmStatic
get() = ScsGrpc.getListPopFrontMethod()
public val listPopBackMethod: MethodDescriptor<_ListPopBackRequest, _ListPopBackResponse>
@JvmStatic
get() = ScsGrpc.getListPopBackMethod()
public val listEraseMethod: MethodDescriptor<_ListEraseRequest, _ListEraseResponse>
@JvmStatic
get() = ScsGrpc.getListEraseMethod()
public val listRemoveMethod: MethodDescriptor<_ListRemoveRequest, _ListRemoveResponse>
@JvmStatic
get() = ScsGrpc.getListRemoveMethod()
public val listFetchMethod: MethodDescriptor<_ListFetchRequest, _ListFetchResponse>
@JvmStatic
get() = ScsGrpc.getListFetchMethod()
public val listLengthMethod: MethodDescriptor<_ListLengthRequest, _ListLengthResponse>
@JvmStatic
get() = ScsGrpc.getListLengthMethod()
public val listConcatenateFrontMethod:
MethodDescriptor<_ListConcatenateFrontRequest, _ListConcatenateFrontResponse>
@JvmStatic
get() = ScsGrpc.getListConcatenateFrontMethod()
public val listConcatenateBackMethod:
MethodDescriptor<_ListConcatenateBackRequest, _ListConcatenateBackResponse>
@JvmStatic
get() = ScsGrpc.getListConcatenateBackMethod()
public val listRetainMethod: MethodDescriptor<_ListRetainRequest, _ListRetainResponse>
@JvmStatic
get() = ScsGrpc.getListRetainMethod()
public val sortedSetPutMethod: MethodDescriptor<_SortedSetPutRequest, _SortedSetPutResponse>
@JvmStatic
get() = ScsGrpc.getSortedSetPutMethod()
public val sortedSetFetchMethod: MethodDescriptor<_SortedSetFetchRequest, _SortedSetFetchResponse>
@JvmStatic
get() = ScsGrpc.getSortedSetFetchMethod()
public val sortedSetGetScoreMethod:
MethodDescriptor<_SortedSetGetScoreRequest, _SortedSetGetScoreResponse>
@JvmStatic
get() = ScsGrpc.getSortedSetGetScoreMethod()
public val sortedSetRemoveMethod:
MethodDescriptor<_SortedSetRemoveRequest, _SortedSetRemoveResponse>
@JvmStatic
get() = ScsGrpc.getSortedSetRemoveMethod()
public val sortedSetIncrementMethod:
MethodDescriptor<_SortedSetIncrementRequest, _SortedSetIncrementResponse>
@JvmStatic
get() = ScsGrpc.getSortedSetIncrementMethod()
public val sortedSetGetRankMethod:
MethodDescriptor<_SortedSetGetRankRequest, _SortedSetGetRankResponse>
@JvmStatic
get() = ScsGrpc.getSortedSetGetRankMethod()
public val sortedSetLengthMethod:
MethodDescriptor<_SortedSetLengthRequest, _SortedSetLengthResponse>
@JvmStatic
get() = ScsGrpc.getSortedSetLengthMethod()
public val sortedSetLengthByScoreMethod:
MethodDescriptor<_SortedSetLengthByScoreRequest, _SortedSetLengthByScoreResponse>
@JvmStatic
get() = ScsGrpc.getSortedSetLengthByScoreMethod()
/**
* A stub for issuing RPCs to a(n) cache_client.Scs service as suspending coroutines.
*/
@StubFor(ScsGrpc::class)
public class ScsCoroutineStub @JvmOverloads constructor(
channel: Channel,
callOptions: CallOptions = DEFAULT,
) : AbstractCoroutineStub(channel, callOptions) {
override fun build(channel: Channel, callOptions: CallOptions): ScsCoroutineStub =
ScsCoroutineStub(channel, callOptions)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun `get`(request: _GetRequest, headers: Metadata = Metadata()): _GetResponse =
unaryRpc(
channel,
ScsGrpc.getGetMethod(),
request,
callOptions,
headers
)
/**
* Returns a [Flow] that, when collected, executes this RPC and emits responses from the
* server as they arrive. That flow finishes normally if the server closes its response with
* [`Status.OK`][io.grpc.Status], and fails by throwing a [StatusException] otherwise. If
* collecting the flow downstream fails exceptionally (including via cancellation), the RPC
* is cancelled with that exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return A flow that, when collected, emits the responses from the server.
*/
public fun getBatch(request: _GetBatchRequest, headers: Metadata = Metadata()):
Flow<_GetResponse> = serverStreamingRpc(
channel,
ScsGrpc.getGetBatchMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun `set`(request: _SetRequest, headers: Metadata = Metadata()): _SetResponse =
unaryRpc(
channel,
ScsGrpc.getSetMethod(),
request,
callOptions,
headers
)
/**
* Returns a [Flow] that, when collected, executes this RPC and emits responses from the
* server as they arrive. That flow finishes normally if the server closes its response with
* [`Status.OK`][io.grpc.Status], and fails by throwing a [StatusException] otherwise. If
* collecting the flow downstream fails exceptionally (including via cancellation), the RPC
* is cancelled with that exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return A flow that, when collected, emits the responses from the server.
*/
public fun setBatch(request: _SetBatchRequest, headers: Metadata = Metadata()):
Flow<_SetResponse> = serverStreamingRpc(
channel,
ScsGrpc.getSetBatchMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun setIf(request: _SetIfRequest, headers: Metadata = Metadata()): _SetIfResponse
= unaryRpc(
channel,
ScsGrpc.getSetIfMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
@Deprecated("The underlying service method is marked deprecated.")
public suspend fun setIfNotExists(request: _SetIfNotExistsRequest, headers: Metadata =
Metadata()): _SetIfNotExistsResponse = unaryRpc(
channel,
ScsGrpc.getSetIfNotExistsMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun delete(request: _DeleteRequest, headers: Metadata = Metadata()):
_DeleteResponse = unaryRpc(
channel,
ScsGrpc.getDeleteMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun keysExist(request: _KeysExistRequest, headers: Metadata = Metadata()):
_KeysExistResponse = unaryRpc(
channel,
ScsGrpc.getKeysExistMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun increment(request: _IncrementRequest, headers: Metadata = Metadata()):
_IncrementResponse = unaryRpc(
channel,
ScsGrpc.getIncrementMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun updateTtl(request: _UpdateTtlRequest, headers: Metadata = Metadata()):
_UpdateTtlResponse = unaryRpc(
channel,
ScsGrpc.getUpdateTtlMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun itemGetTtl(request: _ItemGetTtlRequest, headers: Metadata = Metadata()):
_ItemGetTtlResponse = unaryRpc(
channel,
ScsGrpc.getItemGetTtlMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun itemGetType(request: _ItemGetTypeRequest, headers: Metadata = Metadata()):
_ItemGetTypeResponse = unaryRpc(
channel,
ScsGrpc.getItemGetTypeMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun dictionaryGet(request: _DictionaryGetRequest, headers: Metadata =
Metadata()): _DictionaryGetResponse = unaryRpc(
channel,
ScsGrpc.getDictionaryGetMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun dictionaryFetch(request: _DictionaryFetchRequest, headers: Metadata =
Metadata()): _DictionaryFetchResponse = unaryRpc(
channel,
ScsGrpc.getDictionaryFetchMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun dictionarySet(request: _DictionarySetRequest, headers: Metadata =
Metadata()): _DictionarySetResponse = unaryRpc(
channel,
ScsGrpc.getDictionarySetMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun dictionaryIncrement(request: _DictionaryIncrementRequest, headers: Metadata =
Metadata()): _DictionaryIncrementResponse = unaryRpc(
channel,
ScsGrpc.getDictionaryIncrementMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun dictionaryDelete(request: _DictionaryDeleteRequest, headers: Metadata =
Metadata()): _DictionaryDeleteResponse = unaryRpc(
channel,
ScsGrpc.getDictionaryDeleteMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun dictionaryLength(request: _DictionaryLengthRequest, headers: Metadata =
Metadata()): _DictionaryLengthResponse = unaryRpc(
channel,
ScsGrpc.getDictionaryLengthMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun setFetch(request: _SetFetchRequest, headers: Metadata = Metadata()):
_SetFetchResponse = unaryRpc(
channel,
ScsGrpc.getSetFetchMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun setSample(request: _SetSampleRequest, headers: Metadata = Metadata()):
_SetSampleResponse = unaryRpc(
channel,
ScsGrpc.getSetSampleMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun setUnion(request: _SetUnionRequest, headers: Metadata = Metadata()):
_SetUnionResponse = unaryRpc(
channel,
ScsGrpc.getSetUnionMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun setDifference(request: _SetDifferenceRequest, headers: Metadata =
Metadata()): _SetDifferenceResponse = unaryRpc(
channel,
ScsGrpc.getSetDifferenceMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun setContains(request: _SetContainsRequest, headers: Metadata = Metadata()):
_SetContainsResponse = unaryRpc(
channel,
ScsGrpc.getSetContainsMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun setLength(request: _SetLengthRequest, headers: Metadata = Metadata()):
_SetLengthResponse = unaryRpc(
channel,
ScsGrpc.getSetLengthMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun setPop(request: _SetPopRequest, headers: Metadata = Metadata()):
_SetPopResponse = unaryRpc(
channel,
ScsGrpc.getSetPopMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun listPushFront(request: _ListPushFrontRequest, headers: Metadata =
Metadata()): _ListPushFrontResponse = unaryRpc(
channel,
ScsGrpc.getListPushFrontMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun listPushBack(request: _ListPushBackRequest, headers: Metadata = Metadata()):
_ListPushBackResponse = unaryRpc(
channel,
ScsGrpc.getListPushBackMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun listPopFront(request: _ListPopFrontRequest, headers: Metadata = Metadata()):
_ListPopFrontResponse = unaryRpc(
channel,
ScsGrpc.getListPopFrontMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun listPopBack(request: _ListPopBackRequest, headers: Metadata = Metadata()):
_ListPopBackResponse = unaryRpc(
channel,
ScsGrpc.getListPopBackMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun listErase(request: _ListEraseRequest, headers: Metadata = Metadata()):
_ListEraseResponse = unaryRpc(
channel,
ScsGrpc.getListEraseMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun listRemove(request: _ListRemoveRequest, headers: Metadata = Metadata()):
_ListRemoveResponse = unaryRpc(
channel,
ScsGrpc.getListRemoveMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun listFetch(request: _ListFetchRequest, headers: Metadata = Metadata()):
_ListFetchResponse = unaryRpc(
channel,
ScsGrpc.getListFetchMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun listLength(request: _ListLengthRequest, headers: Metadata = Metadata()):
_ListLengthResponse = unaryRpc(
channel,
ScsGrpc.getListLengthMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun listConcatenateFront(request: _ListConcatenateFrontRequest, headers: Metadata
= Metadata()): _ListConcatenateFrontResponse = unaryRpc(
channel,
ScsGrpc.getListConcatenateFrontMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun listConcatenateBack(request: _ListConcatenateBackRequest, headers: Metadata =
Metadata()): _ListConcatenateBackResponse = unaryRpc(
channel,
ScsGrpc.getListConcatenateBackMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun listRetain(request: _ListRetainRequest, headers: Metadata = Metadata()):
_ListRetainResponse = unaryRpc(
channel,
ScsGrpc.getListRetainMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun sortedSetPut(request: _SortedSetPutRequest, headers: Metadata = Metadata()):
_SortedSetPutResponse = unaryRpc(
channel,
ScsGrpc.getSortedSetPutMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun sortedSetFetch(request: _SortedSetFetchRequest, headers: Metadata =
Metadata()): _SortedSetFetchResponse = unaryRpc(
channel,
ScsGrpc.getSortedSetFetchMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun sortedSetGetScore(request: _SortedSetGetScoreRequest, headers: Metadata =
Metadata()): _SortedSetGetScoreResponse = unaryRpc(
channel,
ScsGrpc.getSortedSetGetScoreMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun sortedSetRemove(request: _SortedSetRemoveRequest, headers: Metadata =
Metadata()): _SortedSetRemoveResponse = unaryRpc(
channel,
ScsGrpc.getSortedSetRemoveMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun sortedSetIncrement(request: _SortedSetIncrementRequest, headers: Metadata =
Metadata()): _SortedSetIncrementResponse = unaryRpc(
channel,
ScsGrpc.getSortedSetIncrementMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun sortedSetGetRank(request: _SortedSetGetRankRequest, headers: Metadata =
Metadata()): _SortedSetGetRankResponse = unaryRpc(
channel,
ScsGrpc.getSortedSetGetRankMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun sortedSetLength(request: _SortedSetLengthRequest, headers: Metadata =
Metadata()): _SortedSetLengthResponse = unaryRpc(
channel,
ScsGrpc.getSortedSetLengthMethod(),
request,
callOptions,
headers
)
/**
* Executes this RPC and returns the response message, suspending until the RPC completes
* with [`Status.OK`][io.grpc.Status]. If the RPC completes with another status, a
* corresponding
* [StatusException] is thrown. If this coroutine is cancelled, the RPC is also cancelled
* with the corresponding exception as a cause.
*
* @param request The request message to send to the server.
*
* @param headers Metadata to attach to the request. Most users will not need this.
*
* @return The single response from the server.
*/
public suspend fun sortedSetLengthByScore(request: _SortedSetLengthByScoreRequest,
headers: Metadata = Metadata()): _SortedSetLengthByScoreResponse = unaryRpc(
channel,
ScsGrpc.getSortedSetLengthByScoreMethod(),
request,
callOptions,
headers
)
}
/**
* Skeletal implementation of the cache_client.Scs service based on Kotlin coroutines.
*/
public abstract class ScsCoroutineImplBase(
coroutineContext: CoroutineContext = EmptyCoroutineContext,
) : AbstractCoroutineServerImpl(coroutineContext) {
/**
* Returns the response to an RPC for cache_client.Scs.Get.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun `get`(request: _GetRequest): _GetResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.Get is unimplemented"))
/**
* Returns a [Flow] of responses to an RPC for cache_client.Scs.GetBatch.
*
* If creating or collecting the returned flow fails with a [StatusException], the RPC
* will fail with the corresponding [io.grpc.Status]. If it fails with a
* [java.util.concurrent.CancellationException], the RPC will fail with status
* `Status.CANCELLED`. If creating
* or collecting the returned flow fails for any other reason, the RPC will fail with
* `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open fun getBatch(request: _GetBatchRequest): Flow<_GetResponse> = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.GetBatch is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.Set.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun `set`(request: _SetRequest): _SetResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.Set is unimplemented"))
/**
* Returns a [Flow] of responses to an RPC for cache_client.Scs.SetBatch.
*
* If creating or collecting the returned flow fails with a [StatusException], the RPC
* will fail with the corresponding [io.grpc.Status]. If it fails with a
* [java.util.concurrent.CancellationException], the RPC will fail with status
* `Status.CANCELLED`. If creating
* or collecting the returned flow fails for any other reason, the RPC will fail with
* `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open fun setBatch(request: _SetBatchRequest): Flow<_SetResponse> = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SetBatch is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SetIf.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun setIf(request: _SetIfRequest): _SetIfResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SetIf is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SetIfNotExists.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
@Deprecated("The underlying service method is marked deprecated.")
public open suspend fun setIfNotExists(request: _SetIfNotExistsRequest): _SetIfNotExistsResponse
= throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SetIfNotExists is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.Delete.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun delete(request: _DeleteRequest): _DeleteResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.Delete is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.KeysExist.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun keysExist(request: _KeysExistRequest): _KeysExistResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.KeysExist is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.Increment.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun increment(request: _IncrementRequest): _IncrementResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.Increment is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.UpdateTtl.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun updateTtl(request: _UpdateTtlRequest): _UpdateTtlResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.UpdateTtl is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.ItemGetTtl.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun itemGetTtl(request: _ItemGetTtlRequest): _ItemGetTtlResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.ItemGetTtl is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.ItemGetType.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun itemGetType(request: _ItemGetTypeRequest): _ItemGetTypeResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.ItemGetType is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.DictionaryGet.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun dictionaryGet(request: _DictionaryGetRequest): _DictionaryGetResponse =
throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.DictionaryGet is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.DictionaryFetch.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun dictionaryFetch(request: _DictionaryFetchRequest):
_DictionaryFetchResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.DictionaryFetch is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.DictionarySet.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun dictionarySet(request: _DictionarySetRequest): _DictionarySetResponse =
throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.DictionarySet is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.DictionaryIncrement.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun dictionaryIncrement(request: _DictionaryIncrementRequest):
_DictionaryIncrementResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.DictionaryIncrement is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.DictionaryDelete.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun dictionaryDelete(request: _DictionaryDeleteRequest):
_DictionaryDeleteResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.DictionaryDelete is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.DictionaryLength.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun dictionaryLength(request: _DictionaryLengthRequest):
_DictionaryLengthResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.DictionaryLength is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SetFetch.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun setFetch(request: _SetFetchRequest): _SetFetchResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SetFetch is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SetSample.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun setSample(request: _SetSampleRequest): _SetSampleResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SetSample is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SetUnion.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun setUnion(request: _SetUnionRequest): _SetUnionResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SetUnion is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SetDifference.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun setDifference(request: _SetDifferenceRequest): _SetDifferenceResponse =
throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SetDifference is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SetContains.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun setContains(request: _SetContainsRequest): _SetContainsResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SetContains is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SetLength.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun setLength(request: _SetLengthRequest): _SetLengthResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SetLength is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SetPop.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun setPop(request: _SetPopRequest): _SetPopResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SetPop is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.ListPushFront.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun listPushFront(request: _ListPushFrontRequest): _ListPushFrontResponse =
throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.ListPushFront is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.ListPushBack.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun listPushBack(request: _ListPushBackRequest): _ListPushBackResponse =
throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.ListPushBack is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.ListPopFront.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun listPopFront(request: _ListPopFrontRequest): _ListPopFrontResponse =
throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.ListPopFront is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.ListPopBack.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun listPopBack(request: _ListPopBackRequest): _ListPopBackResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.ListPopBack is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.ListErase.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun listErase(request: _ListEraseRequest): _ListEraseResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.ListErase is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.ListRemove.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun listRemove(request: _ListRemoveRequest): _ListRemoveResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.ListRemove is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.ListFetch.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun listFetch(request: _ListFetchRequest): _ListFetchResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.ListFetch is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.ListLength.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun listLength(request: _ListLengthRequest): _ListLengthResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.ListLength is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.ListConcatenateFront.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun listConcatenateFront(request: _ListConcatenateFrontRequest):
_ListConcatenateFrontResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.ListConcatenateFront is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.ListConcatenateBack.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun listConcatenateBack(request: _ListConcatenateBackRequest):
_ListConcatenateBackResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.ListConcatenateBack is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.ListRetain.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun listRetain(request: _ListRetainRequest): _ListRetainResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.ListRetain is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SortedSetPut.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun sortedSetPut(request: _SortedSetPutRequest): _SortedSetPutResponse =
throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SortedSetPut is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SortedSetFetch.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun sortedSetFetch(request: _SortedSetFetchRequest): _SortedSetFetchResponse
= throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SortedSetFetch is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SortedSetGetScore.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun sortedSetGetScore(request: _SortedSetGetScoreRequest):
_SortedSetGetScoreResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SortedSetGetScore is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SortedSetRemove.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun sortedSetRemove(request: _SortedSetRemoveRequest):
_SortedSetRemoveResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SortedSetRemove is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SortedSetIncrement.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun sortedSetIncrement(request: _SortedSetIncrementRequest):
_SortedSetIncrementResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SortedSetIncrement is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SortedSetGetRank.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun sortedSetGetRank(request: _SortedSetGetRankRequest):
_SortedSetGetRankResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SortedSetGetRank is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SortedSetLength.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun sortedSetLength(request: _SortedSetLengthRequest):
_SortedSetLengthResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SortedSetLength is unimplemented"))
/**
* Returns the response to an RPC for cache_client.Scs.SortedSetLengthByScore.
*
* If this method fails with a [StatusException], the RPC will fail with the corresponding
* [io.grpc.Status]. If this method fails with a [java.util.concurrent.CancellationException],
* the RPC will fail
* with status `Status.CANCELLED`. If this method fails for any other reason, the RPC will
* fail with `Status.UNKNOWN` with the exception as a cause.
*
* @param request The request from the client.
*/
public open suspend fun sortedSetLengthByScore(request: _SortedSetLengthByScoreRequest):
_SortedSetLengthByScoreResponse = throw
StatusException(UNIMPLEMENTED.withDescription("Method cache_client.Scs.SortedSetLengthByScore is unimplemented"))
final override fun bindService(): ServerServiceDefinition = builder(getServiceDescriptor())
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getGetMethod(),
implementation = ::`get`
))
.addMethod(serverStreamingServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getGetBatchMethod(),
implementation = ::getBatch
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSetMethod(),
implementation = ::`set`
))
.addMethod(serverStreamingServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSetBatchMethod(),
implementation = ::setBatch
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSetIfMethod(),
implementation = ::setIf
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSetIfNotExistsMethod(),
implementation = ::setIfNotExists
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getDeleteMethod(),
implementation = ::delete
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getKeysExistMethod(),
implementation = ::keysExist
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getIncrementMethod(),
implementation = ::increment
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getUpdateTtlMethod(),
implementation = ::updateTtl
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getItemGetTtlMethod(),
implementation = ::itemGetTtl
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getItemGetTypeMethod(),
implementation = ::itemGetType
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getDictionaryGetMethod(),
implementation = ::dictionaryGet
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getDictionaryFetchMethod(),
implementation = ::dictionaryFetch
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getDictionarySetMethod(),
implementation = ::dictionarySet
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getDictionaryIncrementMethod(),
implementation = ::dictionaryIncrement
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getDictionaryDeleteMethod(),
implementation = ::dictionaryDelete
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getDictionaryLengthMethod(),
implementation = ::dictionaryLength
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSetFetchMethod(),
implementation = ::setFetch
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSetSampleMethod(),
implementation = ::setSample
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSetUnionMethod(),
implementation = ::setUnion
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSetDifferenceMethod(),
implementation = ::setDifference
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSetContainsMethod(),
implementation = ::setContains
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSetLengthMethod(),
implementation = ::setLength
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSetPopMethod(),
implementation = ::setPop
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getListPushFrontMethod(),
implementation = ::listPushFront
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getListPushBackMethod(),
implementation = ::listPushBack
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getListPopFrontMethod(),
implementation = ::listPopFront
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getListPopBackMethod(),
implementation = ::listPopBack
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getListEraseMethod(),
implementation = ::listErase
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getListRemoveMethod(),
implementation = ::listRemove
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getListFetchMethod(),
implementation = ::listFetch
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getListLengthMethod(),
implementation = ::listLength
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getListConcatenateFrontMethod(),
implementation = ::listConcatenateFront
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getListConcatenateBackMethod(),
implementation = ::listConcatenateBack
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getListRetainMethod(),
implementation = ::listRetain
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSortedSetPutMethod(),
implementation = ::sortedSetPut
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSortedSetFetchMethod(),
implementation = ::sortedSetFetch
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSortedSetGetScoreMethod(),
implementation = ::sortedSetGetScore
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSortedSetRemoveMethod(),
implementation = ::sortedSetRemove
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSortedSetIncrementMethod(),
implementation = ::sortedSetIncrement
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSortedSetGetRankMethod(),
implementation = ::sortedSetGetRank
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSortedSetLengthMethod(),
implementation = ::sortedSetLength
))
.addMethod(unaryServerMethodDefinition(
context = this.context,
descriptor = ScsGrpc.getSortedSetLengthByScoreMethod(),
implementation = ::sortedSetLengthByScore
)).build()
}
}