ContextServiceGrpc.java

package context;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@io.quarkus.grpc.common.Generated(value = "by gRPC proto compiler (version 1.55.1)", comments = "Source: context.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class ContextServiceGrpc {

    private ContextServiceGrpc() {
    }

    public static final String SERVICE_NAME = "context.ContextService";

    // Static method descriptors that strictly reflect the proto.
    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.ContextIdList> getListContextIdsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "ListContextIds", requestType = context.ContextOuterClass.Empty.class, responseType = context.ContextOuterClass.ContextIdList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.ContextIdList> getListContextIdsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.ContextIdList> getListContextIdsMethod;
        if ((getListContextIdsMethod = ContextServiceGrpc.getListContextIdsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getListContextIdsMethod = ContextServiceGrpc.getListContextIdsMethod) == null) {
                    ContextServiceGrpc.getListContextIdsMethod = getListContextIdsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, context.ContextOuterClass.ContextIdList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListContextIds")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ContextIdList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("ListContextIds")).build();
                }
            }
        }
        return getListContextIdsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.ContextList> getListContextsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "ListContexts", requestType = context.ContextOuterClass.Empty.class, responseType = context.ContextOuterClass.ContextList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.ContextList> getListContextsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.ContextList> getListContextsMethod;
        if ((getListContextsMethod = ContextServiceGrpc.getListContextsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getListContextsMethod = ContextServiceGrpc.getListContextsMethod) == null) {
                    ContextServiceGrpc.getListContextsMethod = getListContextsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, context.ContextOuterClass.ContextList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListContexts")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ContextList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("ListContexts")).build();
                }
            }
        }
        return getListContextsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.Context> getGetContextMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetContext", requestType = context.ContextOuterClass.ContextId.class, responseType = context.ContextOuterClass.Context.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.Context> getGetContextMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.Context> getGetContextMethod;
        if ((getGetContextMethod = ContextServiceGrpc.getGetContextMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetContextMethod = ContextServiceGrpc.getGetContextMethod) == null) {
                    ContextServiceGrpc.getGetContextMethod = getGetContextMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ContextId, context.ContextOuterClass.Context>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetContext")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ContextId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Context.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetContext")).build();
                }
            }
        }
        return getGetContextMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Context, context.ContextOuterClass.ContextId> getSetContextMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "SetContext", requestType = context.ContextOuterClass.Context.class, responseType = context.ContextOuterClass.ContextId.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Context, context.ContextOuterClass.ContextId> getSetContextMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Context, context.ContextOuterClass.ContextId> getSetContextMethod;
        if ((getSetContextMethod = ContextServiceGrpc.getSetContextMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getSetContextMethod = ContextServiceGrpc.getSetContextMethod) == null) {
                    ContextServiceGrpc.getSetContextMethod = getSetContextMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Context, context.ContextOuterClass.ContextId>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetContext")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Context.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ContextId.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("SetContext")).build();
                }
            }
        }
        return getSetContextMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.Empty> getRemoveContextMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "RemoveContext", requestType = context.ContextOuterClass.ContextId.class, responseType = context.ContextOuterClass.Empty.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.Empty> getRemoveContextMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.Empty> getRemoveContextMethod;
        if ((getRemoveContextMethod = ContextServiceGrpc.getRemoveContextMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getRemoveContextMethod = ContextServiceGrpc.getRemoveContextMethod) == null) {
                    ContextServiceGrpc.getRemoveContextMethod = getRemoveContextMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ContextId, context.ContextOuterClass.Empty>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "RemoveContext")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ContextId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("RemoveContext")).build();
                }
            }
        }
        return getRemoveContextMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.ContextEvent> getGetContextEventsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetContextEvents", requestType = context.ContextOuterClass.Empty.class, responseType = context.ContextOuterClass.ContextEvent.class, methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.ContextEvent> getGetContextEventsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.ContextEvent> getGetContextEventsMethod;
        if ((getGetContextEventsMethod = ContextServiceGrpc.getGetContextEventsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetContextEventsMethod = ContextServiceGrpc.getGetContextEventsMethod) == null) {
                    ContextServiceGrpc.getGetContextEventsMethod = getGetContextEventsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, context.ContextOuterClass.ContextEvent>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetContextEvents")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ContextEvent.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetContextEvents")).build();
                }
            }
        }
        return getGetContextEventsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.TopologyIdList> getListTopologyIdsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "ListTopologyIds", requestType = context.ContextOuterClass.ContextId.class, responseType = context.ContextOuterClass.TopologyIdList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.TopologyIdList> getListTopologyIdsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.TopologyIdList> getListTopologyIdsMethod;
        if ((getListTopologyIdsMethod = ContextServiceGrpc.getListTopologyIdsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getListTopologyIdsMethod = ContextServiceGrpc.getListTopologyIdsMethod) == null) {
                    ContextServiceGrpc.getListTopologyIdsMethod = getListTopologyIdsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ContextId, context.ContextOuterClass.TopologyIdList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListTopologyIds")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ContextId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.TopologyIdList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("ListTopologyIds")).build();
                }
            }
        }
        return getListTopologyIdsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.TopologyList> getListTopologiesMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "ListTopologies", requestType = context.ContextOuterClass.ContextId.class, responseType = context.ContextOuterClass.TopologyList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.TopologyList> getListTopologiesMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.TopologyList> getListTopologiesMethod;
        if ((getListTopologiesMethod = ContextServiceGrpc.getListTopologiesMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getListTopologiesMethod = ContextServiceGrpc.getListTopologiesMethod) == null) {
                    ContextServiceGrpc.getListTopologiesMethod = getListTopologiesMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ContextId, context.ContextOuterClass.TopologyList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListTopologies")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ContextId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.TopologyList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("ListTopologies")).build();
                }
            }
        }
        return getListTopologiesMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.TopologyId, context.ContextOuterClass.Topology> getGetTopologyMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetTopology", requestType = context.ContextOuterClass.TopologyId.class, responseType = context.ContextOuterClass.Topology.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.TopologyId, context.ContextOuterClass.Topology> getGetTopologyMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.TopologyId, context.ContextOuterClass.Topology> getGetTopologyMethod;
        if ((getGetTopologyMethod = ContextServiceGrpc.getGetTopologyMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetTopologyMethod = ContextServiceGrpc.getGetTopologyMethod) == null) {
                    ContextServiceGrpc.getGetTopologyMethod = getGetTopologyMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.TopologyId, context.ContextOuterClass.Topology>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetTopology")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.TopologyId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Topology.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetTopology")).build();
                }
            }
        }
        return getGetTopologyMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.TopologyId, context.ContextOuterClass.TopologyDetails> getGetTopologyDetailsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetTopologyDetails", requestType = context.ContextOuterClass.TopologyId.class, responseType = context.ContextOuterClass.TopologyDetails.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.TopologyId, context.ContextOuterClass.TopologyDetails> getGetTopologyDetailsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.TopologyId, context.ContextOuterClass.TopologyDetails> getGetTopologyDetailsMethod;
        if ((getGetTopologyDetailsMethod = ContextServiceGrpc.getGetTopologyDetailsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetTopologyDetailsMethod = ContextServiceGrpc.getGetTopologyDetailsMethod) == null) {
                    ContextServiceGrpc.getGetTopologyDetailsMethod = getGetTopologyDetailsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.TopologyId, context.ContextOuterClass.TopologyDetails>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetTopologyDetails")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.TopologyId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.TopologyDetails.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetTopologyDetails")).build();
                }
            }
        }
        return getGetTopologyDetailsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Topology, context.ContextOuterClass.TopologyId> getSetTopologyMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "SetTopology", requestType = context.ContextOuterClass.Topology.class, responseType = context.ContextOuterClass.TopologyId.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Topology, context.ContextOuterClass.TopologyId> getSetTopologyMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Topology, context.ContextOuterClass.TopologyId> getSetTopologyMethod;
        if ((getSetTopologyMethod = ContextServiceGrpc.getSetTopologyMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getSetTopologyMethod = ContextServiceGrpc.getSetTopologyMethod) == null) {
                    ContextServiceGrpc.getSetTopologyMethod = getSetTopologyMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Topology, context.ContextOuterClass.TopologyId>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetTopology")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Topology.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.TopologyId.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("SetTopology")).build();
                }
            }
        }
        return getSetTopologyMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.TopologyId, context.ContextOuterClass.Empty> getRemoveTopologyMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "RemoveTopology", requestType = context.ContextOuterClass.TopologyId.class, responseType = context.ContextOuterClass.Empty.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.TopologyId, context.ContextOuterClass.Empty> getRemoveTopologyMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.TopologyId, context.ContextOuterClass.Empty> getRemoveTopologyMethod;
        if ((getRemoveTopologyMethod = ContextServiceGrpc.getRemoveTopologyMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getRemoveTopologyMethod = ContextServiceGrpc.getRemoveTopologyMethod) == null) {
                    ContextServiceGrpc.getRemoveTopologyMethod = getRemoveTopologyMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.TopologyId, context.ContextOuterClass.Empty>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "RemoveTopology")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.TopologyId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("RemoveTopology")).build();
                }
            }
        }
        return getRemoveTopologyMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.TopologyEvent> getGetTopologyEventsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetTopologyEvents", requestType = context.ContextOuterClass.Empty.class, responseType = context.ContextOuterClass.TopologyEvent.class, methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.TopologyEvent> getGetTopologyEventsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.TopologyEvent> getGetTopologyEventsMethod;
        if ((getGetTopologyEventsMethod = ContextServiceGrpc.getGetTopologyEventsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetTopologyEventsMethod = ContextServiceGrpc.getGetTopologyEventsMethod) == null) {
                    ContextServiceGrpc.getGetTopologyEventsMethod = getGetTopologyEventsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, context.ContextOuterClass.TopologyEvent>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetTopologyEvents")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.TopologyEvent.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetTopologyEvents")).build();
                }
            }
        }
        return getGetTopologyEventsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.DeviceIdList> getListDeviceIdsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "ListDeviceIds", requestType = context.ContextOuterClass.Empty.class, responseType = context.ContextOuterClass.DeviceIdList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.DeviceIdList> getListDeviceIdsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.DeviceIdList> getListDeviceIdsMethod;
        if ((getListDeviceIdsMethod = ContextServiceGrpc.getListDeviceIdsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getListDeviceIdsMethod = ContextServiceGrpc.getListDeviceIdsMethod) == null) {
                    ContextServiceGrpc.getListDeviceIdsMethod = getListDeviceIdsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, context.ContextOuterClass.DeviceIdList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListDeviceIds")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.DeviceIdList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("ListDeviceIds")).build();
                }
            }
        }
        return getListDeviceIdsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.DeviceList> getListDevicesMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "ListDevices", requestType = context.ContextOuterClass.Empty.class, responseType = context.ContextOuterClass.DeviceList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.DeviceList> getListDevicesMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.DeviceList> getListDevicesMethod;
        if ((getListDevicesMethod = ContextServiceGrpc.getListDevicesMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getListDevicesMethod = ContextServiceGrpc.getListDevicesMethod) == null) {
                    ContextServiceGrpc.getListDevicesMethod = getListDevicesMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, context.ContextOuterClass.DeviceList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListDevices")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.DeviceList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("ListDevices")).build();
                }
            }
        }
        return getListDevicesMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.DeviceId, context.ContextOuterClass.Device> getGetDeviceMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetDevice", requestType = context.ContextOuterClass.DeviceId.class, responseType = context.ContextOuterClass.Device.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.DeviceId, context.ContextOuterClass.Device> getGetDeviceMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.DeviceId, context.ContextOuterClass.Device> getGetDeviceMethod;
        if ((getGetDeviceMethod = ContextServiceGrpc.getGetDeviceMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetDeviceMethod = ContextServiceGrpc.getGetDeviceMethod) == null) {
                    ContextServiceGrpc.getGetDeviceMethod = getGetDeviceMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.DeviceId, context.ContextOuterClass.Device>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetDevice")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.DeviceId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Device.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetDevice")).build();
                }
            }
        }
        return getGetDeviceMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Device, context.ContextOuterClass.DeviceId> getSetDeviceMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "SetDevice", requestType = context.ContextOuterClass.Device.class, responseType = context.ContextOuterClass.DeviceId.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Device, context.ContextOuterClass.DeviceId> getSetDeviceMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Device, context.ContextOuterClass.DeviceId> getSetDeviceMethod;
        if ((getSetDeviceMethod = ContextServiceGrpc.getSetDeviceMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getSetDeviceMethod = ContextServiceGrpc.getSetDeviceMethod) == null) {
                    ContextServiceGrpc.getSetDeviceMethod = getSetDeviceMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Device, context.ContextOuterClass.DeviceId>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetDevice")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Device.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.DeviceId.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("SetDevice")).build();
                }
            }
        }
        return getSetDeviceMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.DeviceId, context.ContextOuterClass.Empty> getRemoveDeviceMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "RemoveDevice", requestType = context.ContextOuterClass.DeviceId.class, responseType = context.ContextOuterClass.Empty.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.DeviceId, context.ContextOuterClass.Empty> getRemoveDeviceMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.DeviceId, context.ContextOuterClass.Empty> getRemoveDeviceMethod;
        if ((getRemoveDeviceMethod = ContextServiceGrpc.getRemoveDeviceMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getRemoveDeviceMethod = ContextServiceGrpc.getRemoveDeviceMethod) == null) {
                    ContextServiceGrpc.getRemoveDeviceMethod = getRemoveDeviceMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.DeviceId, context.ContextOuterClass.Empty>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "RemoveDevice")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.DeviceId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("RemoveDevice")).build();
                }
            }
        }
        return getRemoveDeviceMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.DeviceEvent> getGetDeviceEventsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetDeviceEvents", requestType = context.ContextOuterClass.Empty.class, responseType = context.ContextOuterClass.DeviceEvent.class, methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.DeviceEvent> getGetDeviceEventsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.DeviceEvent> getGetDeviceEventsMethod;
        if ((getGetDeviceEventsMethod = ContextServiceGrpc.getGetDeviceEventsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetDeviceEventsMethod = ContextServiceGrpc.getGetDeviceEventsMethod) == null) {
                    ContextServiceGrpc.getGetDeviceEventsMethod = getGetDeviceEventsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, context.ContextOuterClass.DeviceEvent>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetDeviceEvents")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.DeviceEvent.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetDeviceEvents")).build();
                }
            }
        }
        return getGetDeviceEventsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.DeviceFilter, context.ContextOuterClass.DeviceList> getSelectDeviceMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "SelectDevice", requestType = context.ContextOuterClass.DeviceFilter.class, responseType = context.ContextOuterClass.DeviceList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.DeviceFilter, context.ContextOuterClass.DeviceList> getSelectDeviceMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.DeviceFilter, context.ContextOuterClass.DeviceList> getSelectDeviceMethod;
        if ((getSelectDeviceMethod = ContextServiceGrpc.getSelectDeviceMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getSelectDeviceMethod = ContextServiceGrpc.getSelectDeviceMethod) == null) {
                    ContextServiceGrpc.getSelectDeviceMethod = getSelectDeviceMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.DeviceFilter, context.ContextOuterClass.DeviceList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "SelectDevice")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.DeviceFilter.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.DeviceList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("SelectDevice")).build();
                }
            }
        }
        return getSelectDeviceMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.EndPointIdList, context.ContextOuterClass.EndPointNameList> getListEndPointNamesMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "ListEndPointNames", requestType = context.ContextOuterClass.EndPointIdList.class, responseType = context.ContextOuterClass.EndPointNameList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.EndPointIdList, context.ContextOuterClass.EndPointNameList> getListEndPointNamesMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.EndPointIdList, context.ContextOuterClass.EndPointNameList> getListEndPointNamesMethod;
        if ((getListEndPointNamesMethod = ContextServiceGrpc.getListEndPointNamesMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getListEndPointNamesMethod = ContextServiceGrpc.getListEndPointNamesMethod) == null) {
                    ContextServiceGrpc.getListEndPointNamesMethod = getListEndPointNamesMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.EndPointIdList, context.ContextOuterClass.EndPointNameList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListEndPointNames")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.EndPointIdList.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.EndPointNameList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("ListEndPointNames")).build();
                }
            }
        }
        return getListEndPointNamesMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.LinkIdList> getListLinkIdsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "ListLinkIds", requestType = context.ContextOuterClass.Empty.class, responseType = context.ContextOuterClass.LinkIdList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.LinkIdList> getListLinkIdsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.LinkIdList> getListLinkIdsMethod;
        if ((getListLinkIdsMethod = ContextServiceGrpc.getListLinkIdsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getListLinkIdsMethod = ContextServiceGrpc.getListLinkIdsMethod) == null) {
                    ContextServiceGrpc.getListLinkIdsMethod = getListLinkIdsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, context.ContextOuterClass.LinkIdList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListLinkIds")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.LinkIdList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("ListLinkIds")).build();
                }
            }
        }
        return getListLinkIdsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.LinkList> getListLinksMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "ListLinks", requestType = context.ContextOuterClass.Empty.class, responseType = context.ContextOuterClass.LinkList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.LinkList> getListLinksMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.LinkList> getListLinksMethod;
        if ((getListLinksMethod = ContextServiceGrpc.getListLinksMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getListLinksMethod = ContextServiceGrpc.getListLinksMethod) == null) {
                    ContextServiceGrpc.getListLinksMethod = getListLinksMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, context.ContextOuterClass.LinkList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListLinks")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.LinkList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("ListLinks")).build();
                }
            }
        }
        return getListLinksMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.LinkId, context.ContextOuterClass.Link> getGetLinkMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetLink", requestType = context.ContextOuterClass.LinkId.class, responseType = context.ContextOuterClass.Link.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.LinkId, context.ContextOuterClass.Link> getGetLinkMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.LinkId, context.ContextOuterClass.Link> getGetLinkMethod;
        if ((getGetLinkMethod = ContextServiceGrpc.getGetLinkMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetLinkMethod = ContextServiceGrpc.getGetLinkMethod) == null) {
                    ContextServiceGrpc.getGetLinkMethod = getGetLinkMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.LinkId, context.ContextOuterClass.Link>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetLink")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.LinkId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Link.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetLink")).build();
                }
            }
        }
        return getGetLinkMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Link, context.ContextOuterClass.LinkId> getSetLinkMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "SetLink", requestType = context.ContextOuterClass.Link.class, responseType = context.ContextOuterClass.LinkId.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Link, context.ContextOuterClass.LinkId> getSetLinkMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Link, context.ContextOuterClass.LinkId> getSetLinkMethod;
        if ((getSetLinkMethod = ContextServiceGrpc.getSetLinkMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getSetLinkMethod = ContextServiceGrpc.getSetLinkMethod) == null) {
                    ContextServiceGrpc.getSetLinkMethod = getSetLinkMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Link, context.ContextOuterClass.LinkId>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetLink")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Link.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.LinkId.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("SetLink")).build();
                }
            }
        }
        return getSetLinkMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.LinkId, context.ContextOuterClass.Empty> getRemoveLinkMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "RemoveLink", requestType = context.ContextOuterClass.LinkId.class, responseType = context.ContextOuterClass.Empty.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.LinkId, context.ContextOuterClass.Empty> getRemoveLinkMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.LinkId, context.ContextOuterClass.Empty> getRemoveLinkMethod;
        if ((getRemoveLinkMethod = ContextServiceGrpc.getRemoveLinkMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getRemoveLinkMethod = ContextServiceGrpc.getRemoveLinkMethod) == null) {
                    ContextServiceGrpc.getRemoveLinkMethod = getRemoveLinkMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.LinkId, context.ContextOuterClass.Empty>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "RemoveLink")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.LinkId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("RemoveLink")).build();
                }
            }
        }
        return getRemoveLinkMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.LinkEvent> getGetLinkEventsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetLinkEvents", requestType = context.ContextOuterClass.Empty.class, responseType = context.ContextOuterClass.LinkEvent.class, methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.LinkEvent> getGetLinkEventsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.LinkEvent> getGetLinkEventsMethod;
        if ((getGetLinkEventsMethod = ContextServiceGrpc.getGetLinkEventsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetLinkEventsMethod = ContextServiceGrpc.getGetLinkEventsMethod) == null) {
                    ContextServiceGrpc.getGetLinkEventsMethod = getGetLinkEventsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, context.ContextOuterClass.LinkEvent>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetLinkEvents")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.LinkEvent.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetLinkEvents")).build();
                }
            }
        }
        return getGetLinkEventsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.ServiceIdList> getListServiceIdsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "ListServiceIds", requestType = context.ContextOuterClass.ContextId.class, responseType = context.ContextOuterClass.ServiceIdList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.ServiceIdList> getListServiceIdsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.ServiceIdList> getListServiceIdsMethod;
        if ((getListServiceIdsMethod = ContextServiceGrpc.getListServiceIdsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getListServiceIdsMethod = ContextServiceGrpc.getListServiceIdsMethod) == null) {
                    ContextServiceGrpc.getListServiceIdsMethod = getListServiceIdsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ContextId, context.ContextOuterClass.ServiceIdList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListServiceIds")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ContextId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ServiceIdList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("ListServiceIds")).build();
                }
            }
        }
        return getListServiceIdsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.ServiceList> getListServicesMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "ListServices", requestType = context.ContextOuterClass.ContextId.class, responseType = context.ContextOuterClass.ServiceList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.ServiceList> getListServicesMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.ServiceList> getListServicesMethod;
        if ((getListServicesMethod = ContextServiceGrpc.getListServicesMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getListServicesMethod = ContextServiceGrpc.getListServicesMethod) == null) {
                    ContextServiceGrpc.getListServicesMethod = getListServicesMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ContextId, context.ContextOuterClass.ServiceList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListServices")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ContextId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ServiceList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("ListServices")).build();
                }
            }
        }
        return getListServicesMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceId, context.ContextOuterClass.Service> getGetServiceMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetService", requestType = context.ContextOuterClass.ServiceId.class, responseType = context.ContextOuterClass.Service.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceId, context.ContextOuterClass.Service> getGetServiceMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceId, context.ContextOuterClass.Service> getGetServiceMethod;
        if ((getGetServiceMethod = ContextServiceGrpc.getGetServiceMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetServiceMethod = ContextServiceGrpc.getGetServiceMethod) == null) {
                    ContextServiceGrpc.getGetServiceMethod = getGetServiceMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ServiceId, context.ContextOuterClass.Service>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetService")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ServiceId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Service.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetService")).build();
                }
            }
        }
        return getGetServiceMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Service, context.ContextOuterClass.ServiceId> getSetServiceMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "SetService", requestType = context.ContextOuterClass.Service.class, responseType = context.ContextOuterClass.ServiceId.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Service, context.ContextOuterClass.ServiceId> getSetServiceMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Service, context.ContextOuterClass.ServiceId> getSetServiceMethod;
        if ((getSetServiceMethod = ContextServiceGrpc.getSetServiceMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getSetServiceMethod = ContextServiceGrpc.getSetServiceMethod) == null) {
                    ContextServiceGrpc.getSetServiceMethod = getSetServiceMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Service, context.ContextOuterClass.ServiceId>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetService")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Service.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ServiceId.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("SetService")).build();
                }
            }
        }
        return getSetServiceMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Service, context.ContextOuterClass.ServiceId> getUnsetServiceMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "UnsetService", requestType = context.ContextOuterClass.Service.class, responseType = context.ContextOuterClass.ServiceId.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Service, context.ContextOuterClass.ServiceId> getUnsetServiceMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Service, context.ContextOuterClass.ServiceId> getUnsetServiceMethod;
        if ((getUnsetServiceMethod = ContextServiceGrpc.getUnsetServiceMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getUnsetServiceMethod = ContextServiceGrpc.getUnsetServiceMethod) == null) {
                    ContextServiceGrpc.getUnsetServiceMethod = getUnsetServiceMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Service, context.ContextOuterClass.ServiceId>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnsetService")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Service.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ServiceId.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("UnsetService")).build();
                }
            }
        }
        return getUnsetServiceMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceId, context.ContextOuterClass.Empty> getRemoveServiceMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "RemoveService", requestType = context.ContextOuterClass.ServiceId.class, responseType = context.ContextOuterClass.Empty.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceId, context.ContextOuterClass.Empty> getRemoveServiceMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceId, context.ContextOuterClass.Empty> getRemoveServiceMethod;
        if ((getRemoveServiceMethod = ContextServiceGrpc.getRemoveServiceMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getRemoveServiceMethod = ContextServiceGrpc.getRemoveServiceMethod) == null) {
                    ContextServiceGrpc.getRemoveServiceMethod = getRemoveServiceMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ServiceId, context.ContextOuterClass.Empty>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "RemoveService")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ServiceId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("RemoveService")).build();
                }
            }
        }
        return getRemoveServiceMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.ServiceEvent> getGetServiceEventsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetServiceEvents", requestType = context.ContextOuterClass.Empty.class, responseType = context.ContextOuterClass.ServiceEvent.class, methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.ServiceEvent> getGetServiceEventsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.ServiceEvent> getGetServiceEventsMethod;
        if ((getGetServiceEventsMethod = ContextServiceGrpc.getGetServiceEventsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetServiceEventsMethod = ContextServiceGrpc.getGetServiceEventsMethod) == null) {
                    ContextServiceGrpc.getGetServiceEventsMethod = getGetServiceEventsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, context.ContextOuterClass.ServiceEvent>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetServiceEvents")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ServiceEvent.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetServiceEvents")).build();
                }
            }
        }
        return getGetServiceEventsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceFilter, context.ContextOuterClass.ServiceList> getSelectServiceMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "SelectService", requestType = context.ContextOuterClass.ServiceFilter.class, responseType = context.ContextOuterClass.ServiceList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceFilter, context.ContextOuterClass.ServiceList> getSelectServiceMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceFilter, context.ContextOuterClass.ServiceList> getSelectServiceMethod;
        if ((getSelectServiceMethod = ContextServiceGrpc.getSelectServiceMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getSelectServiceMethod = ContextServiceGrpc.getSelectServiceMethod) == null) {
                    ContextServiceGrpc.getSelectServiceMethod = getSelectServiceMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ServiceFilter, context.ContextOuterClass.ServiceList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "SelectService")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ServiceFilter.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ServiceList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("SelectService")).build();
                }
            }
        }
        return getSelectServiceMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.SliceIdList> getListSliceIdsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "ListSliceIds", requestType = context.ContextOuterClass.ContextId.class, responseType = context.ContextOuterClass.SliceIdList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.SliceIdList> getListSliceIdsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.SliceIdList> getListSliceIdsMethod;
        if ((getListSliceIdsMethod = ContextServiceGrpc.getListSliceIdsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getListSliceIdsMethod = ContextServiceGrpc.getListSliceIdsMethod) == null) {
                    ContextServiceGrpc.getListSliceIdsMethod = getListSliceIdsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ContextId, context.ContextOuterClass.SliceIdList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListSliceIds")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ContextId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.SliceIdList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("ListSliceIds")).build();
                }
            }
        }
        return getListSliceIdsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.SliceList> getListSlicesMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "ListSlices", requestType = context.ContextOuterClass.ContextId.class, responseType = context.ContextOuterClass.SliceList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.SliceList> getListSlicesMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ContextId, context.ContextOuterClass.SliceList> getListSlicesMethod;
        if ((getListSlicesMethod = ContextServiceGrpc.getListSlicesMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getListSlicesMethod = ContextServiceGrpc.getListSlicesMethod) == null) {
                    ContextServiceGrpc.getListSlicesMethod = getListSlicesMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ContextId, context.ContextOuterClass.SliceList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListSlices")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ContextId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.SliceList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("ListSlices")).build();
                }
            }
        }
        return getListSlicesMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.SliceId, context.ContextOuterClass.Slice> getGetSliceMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetSlice", requestType = context.ContextOuterClass.SliceId.class, responseType = context.ContextOuterClass.Slice.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.SliceId, context.ContextOuterClass.Slice> getGetSliceMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.SliceId, context.ContextOuterClass.Slice> getGetSliceMethod;
        if ((getGetSliceMethod = ContextServiceGrpc.getGetSliceMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetSliceMethod = ContextServiceGrpc.getGetSliceMethod) == null) {
                    ContextServiceGrpc.getGetSliceMethod = getGetSliceMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.SliceId, context.ContextOuterClass.Slice>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetSlice")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.SliceId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Slice.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetSlice")).build();
                }
            }
        }
        return getGetSliceMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Slice, context.ContextOuterClass.SliceId> getSetSliceMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "SetSlice", requestType = context.ContextOuterClass.Slice.class, responseType = context.ContextOuterClass.SliceId.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Slice, context.ContextOuterClass.SliceId> getSetSliceMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Slice, context.ContextOuterClass.SliceId> getSetSliceMethod;
        if ((getSetSliceMethod = ContextServiceGrpc.getSetSliceMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getSetSliceMethod = ContextServiceGrpc.getSetSliceMethod) == null) {
                    ContextServiceGrpc.getSetSliceMethod = getSetSliceMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Slice, context.ContextOuterClass.SliceId>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetSlice")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Slice.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.SliceId.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("SetSlice")).build();
                }
            }
        }
        return getSetSliceMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Slice, context.ContextOuterClass.SliceId> getUnsetSliceMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "UnsetSlice", requestType = context.ContextOuterClass.Slice.class, responseType = context.ContextOuterClass.SliceId.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Slice, context.ContextOuterClass.SliceId> getUnsetSliceMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Slice, context.ContextOuterClass.SliceId> getUnsetSliceMethod;
        if ((getUnsetSliceMethod = ContextServiceGrpc.getUnsetSliceMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getUnsetSliceMethod = ContextServiceGrpc.getUnsetSliceMethod) == null) {
                    ContextServiceGrpc.getUnsetSliceMethod = getUnsetSliceMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Slice, context.ContextOuterClass.SliceId>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnsetSlice")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Slice.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.SliceId.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("UnsetSlice")).build();
                }
            }
        }
        return getUnsetSliceMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.SliceId, context.ContextOuterClass.Empty> getRemoveSliceMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "RemoveSlice", requestType = context.ContextOuterClass.SliceId.class, responseType = context.ContextOuterClass.Empty.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.SliceId, context.ContextOuterClass.Empty> getRemoveSliceMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.SliceId, context.ContextOuterClass.Empty> getRemoveSliceMethod;
        if ((getRemoveSliceMethod = ContextServiceGrpc.getRemoveSliceMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getRemoveSliceMethod = ContextServiceGrpc.getRemoveSliceMethod) == null) {
                    ContextServiceGrpc.getRemoveSliceMethod = getRemoveSliceMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.SliceId, context.ContextOuterClass.Empty>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "RemoveSlice")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.SliceId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("RemoveSlice")).build();
                }
            }
        }
        return getRemoveSliceMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.SliceEvent> getGetSliceEventsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetSliceEvents", requestType = context.ContextOuterClass.Empty.class, responseType = context.ContextOuterClass.SliceEvent.class, methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.SliceEvent> getGetSliceEventsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.SliceEvent> getGetSliceEventsMethod;
        if ((getGetSliceEventsMethod = ContextServiceGrpc.getGetSliceEventsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetSliceEventsMethod = ContextServiceGrpc.getGetSliceEventsMethod) == null) {
                    ContextServiceGrpc.getGetSliceEventsMethod = getGetSliceEventsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, context.ContextOuterClass.SliceEvent>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetSliceEvents")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.SliceEvent.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetSliceEvents")).build();
                }
            }
        }
        return getGetSliceEventsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.SliceFilter, context.ContextOuterClass.SliceList> getSelectSliceMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "SelectSlice", requestType = context.ContextOuterClass.SliceFilter.class, responseType = context.ContextOuterClass.SliceList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.SliceFilter, context.ContextOuterClass.SliceList> getSelectSliceMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.SliceFilter, context.ContextOuterClass.SliceList> getSelectSliceMethod;
        if ((getSelectSliceMethod = ContextServiceGrpc.getSelectSliceMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getSelectSliceMethod = ContextServiceGrpc.getSelectSliceMethod) == null) {
                    ContextServiceGrpc.getSelectSliceMethod = getSelectSliceMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.SliceFilter, context.ContextOuterClass.SliceList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "SelectSlice")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.SliceFilter.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.SliceList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("SelectSlice")).build();
                }
            }
        }
        return getSelectSliceMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceId, context.ContextOuterClass.ConnectionIdList> getListConnectionIdsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "ListConnectionIds", requestType = context.ContextOuterClass.ServiceId.class, responseType = context.ContextOuterClass.ConnectionIdList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceId, context.ContextOuterClass.ConnectionIdList> getListConnectionIdsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceId, context.ContextOuterClass.ConnectionIdList> getListConnectionIdsMethod;
        if ((getListConnectionIdsMethod = ContextServiceGrpc.getListConnectionIdsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getListConnectionIdsMethod = ContextServiceGrpc.getListConnectionIdsMethod) == null) {
                    ContextServiceGrpc.getListConnectionIdsMethod = getListConnectionIdsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ServiceId, context.ContextOuterClass.ConnectionIdList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListConnectionIds")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ServiceId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ConnectionIdList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("ListConnectionIds")).build();
                }
            }
        }
        return getListConnectionIdsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceId, context.ContextOuterClass.ConnectionList> getListConnectionsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "ListConnections", requestType = context.ContextOuterClass.ServiceId.class, responseType = context.ContextOuterClass.ConnectionList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceId, context.ContextOuterClass.ConnectionList> getListConnectionsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceId, context.ContextOuterClass.ConnectionList> getListConnectionsMethod;
        if ((getListConnectionsMethod = ContextServiceGrpc.getListConnectionsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getListConnectionsMethod = ContextServiceGrpc.getListConnectionsMethod) == null) {
                    ContextServiceGrpc.getListConnectionsMethod = getListConnectionsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ServiceId, context.ContextOuterClass.ConnectionList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListConnections")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ServiceId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ConnectionList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("ListConnections")).build();
                }
            }
        }
        return getListConnectionsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ConnectionId, context.ContextOuterClass.Connection> getGetConnectionMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetConnection", requestType = context.ContextOuterClass.ConnectionId.class, responseType = context.ContextOuterClass.Connection.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ConnectionId, context.ContextOuterClass.Connection> getGetConnectionMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ConnectionId, context.ContextOuterClass.Connection> getGetConnectionMethod;
        if ((getGetConnectionMethod = ContextServiceGrpc.getGetConnectionMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetConnectionMethod = ContextServiceGrpc.getGetConnectionMethod) == null) {
                    ContextServiceGrpc.getGetConnectionMethod = getGetConnectionMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ConnectionId, context.ContextOuterClass.Connection>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetConnection")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ConnectionId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Connection.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetConnection")).build();
                }
            }
        }
        return getGetConnectionMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Connection, context.ContextOuterClass.ConnectionId> getSetConnectionMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "SetConnection", requestType = context.ContextOuterClass.Connection.class, responseType = context.ContextOuterClass.ConnectionId.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Connection, context.ContextOuterClass.ConnectionId> getSetConnectionMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Connection, context.ContextOuterClass.ConnectionId> getSetConnectionMethod;
        if ((getSetConnectionMethod = ContextServiceGrpc.getSetConnectionMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getSetConnectionMethod = ContextServiceGrpc.getSetConnectionMethod) == null) {
                    ContextServiceGrpc.getSetConnectionMethod = getSetConnectionMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Connection, context.ContextOuterClass.ConnectionId>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetConnection")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Connection.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ConnectionId.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("SetConnection")).build();
                }
            }
        }
        return getSetConnectionMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ConnectionId, context.ContextOuterClass.Empty> getRemoveConnectionMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "RemoveConnection", requestType = context.ContextOuterClass.ConnectionId.class, responseType = context.ContextOuterClass.Empty.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ConnectionId, context.ContextOuterClass.Empty> getRemoveConnectionMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ConnectionId, context.ContextOuterClass.Empty> getRemoveConnectionMethod;
        if ((getRemoveConnectionMethod = ContextServiceGrpc.getRemoveConnectionMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getRemoveConnectionMethod = ContextServiceGrpc.getRemoveConnectionMethod) == null) {
                    ContextServiceGrpc.getRemoveConnectionMethod = getRemoveConnectionMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ConnectionId, context.ContextOuterClass.Empty>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "RemoveConnection")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ConnectionId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("RemoveConnection")).build();
                }
            }
        }
        return getRemoveConnectionMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.ConnectionEvent> getGetConnectionEventsMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetConnectionEvents", requestType = context.ContextOuterClass.Empty.class, responseType = context.ContextOuterClass.ConnectionEvent.class, methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.ConnectionEvent> getGetConnectionEventsMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.ConnectionEvent> getGetConnectionEventsMethod;
        if ((getGetConnectionEventsMethod = ContextServiceGrpc.getGetConnectionEventsMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetConnectionEventsMethod = ContextServiceGrpc.getGetConnectionEventsMethod) == null) {
                    ContextServiceGrpc.getGetConnectionEventsMethod = getGetConnectionEventsMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, context.ContextOuterClass.ConnectionEvent>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetConnectionEvents")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ConnectionEvent.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetConnectionEvents")).build();
                }
            }
        }
        return getGetConnectionEventsMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.OpticalConfigList> getGetOpticalConfigMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetOpticalConfig", requestType = context.ContextOuterClass.Empty.class, responseType = context.ContextOuterClass.OpticalConfigList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.OpticalConfigList> getGetOpticalConfigMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.OpticalConfigList> getGetOpticalConfigMethod;
        if ((getGetOpticalConfigMethod = ContextServiceGrpc.getGetOpticalConfigMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetOpticalConfigMethod = ContextServiceGrpc.getGetOpticalConfigMethod) == null) {
                    ContextServiceGrpc.getGetOpticalConfigMethod = getGetOpticalConfigMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, context.ContextOuterClass.OpticalConfigList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetOpticalConfig")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.OpticalConfigList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetOpticalConfig")).build();
                }
            }
        }
        return getGetOpticalConfigMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalConfig, context.ContextOuterClass.OpticalConfigId> getSetOpticalConfigMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "SetOpticalConfig", requestType = context.ContextOuterClass.OpticalConfig.class, responseType = context.ContextOuterClass.OpticalConfigId.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalConfig, context.ContextOuterClass.OpticalConfigId> getSetOpticalConfigMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalConfig, context.ContextOuterClass.OpticalConfigId> getSetOpticalConfigMethod;
        if ((getSetOpticalConfigMethod = ContextServiceGrpc.getSetOpticalConfigMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getSetOpticalConfigMethod = ContextServiceGrpc.getSetOpticalConfigMethod) == null) {
                    ContextServiceGrpc.getSetOpticalConfigMethod = getSetOpticalConfigMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.OpticalConfig, context.ContextOuterClass.OpticalConfigId>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetOpticalConfig")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.OpticalConfig.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.OpticalConfigId.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("SetOpticalConfig")).build();
                }
            }
        }
        return getSetOpticalConfigMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalConfig, context.ContextOuterClass.OpticalConfigId> getUpdateOpticalConfigMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "UpdateOpticalConfig", requestType = context.ContextOuterClass.OpticalConfig.class, responseType = context.ContextOuterClass.OpticalConfigId.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalConfig, context.ContextOuterClass.OpticalConfigId> getUpdateOpticalConfigMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalConfig, context.ContextOuterClass.OpticalConfigId> getUpdateOpticalConfigMethod;
        if ((getUpdateOpticalConfigMethod = ContextServiceGrpc.getUpdateOpticalConfigMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getUpdateOpticalConfigMethod = ContextServiceGrpc.getUpdateOpticalConfigMethod) == null) {
                    ContextServiceGrpc.getUpdateOpticalConfigMethod = getUpdateOpticalConfigMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.OpticalConfig, context.ContextOuterClass.OpticalConfigId>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "UpdateOpticalConfig")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.OpticalConfig.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.OpticalConfigId.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("UpdateOpticalConfig")).build();
                }
            }
        }
        return getUpdateOpticalConfigMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalConfigId, context.ContextOuterClass.OpticalConfig> getSelectOpticalConfigMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "SelectOpticalConfig", requestType = context.ContextOuterClass.OpticalConfigId.class, responseType = context.ContextOuterClass.OpticalConfig.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalConfigId, context.ContextOuterClass.OpticalConfig> getSelectOpticalConfigMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalConfigId, context.ContextOuterClass.OpticalConfig> getSelectOpticalConfigMethod;
        if ((getSelectOpticalConfigMethod = ContextServiceGrpc.getSelectOpticalConfigMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getSelectOpticalConfigMethod = ContextServiceGrpc.getSelectOpticalConfigMethod) == null) {
                    ContextServiceGrpc.getSelectOpticalConfigMethod = getSelectOpticalConfigMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.OpticalConfigId, context.ContextOuterClass.OpticalConfig>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "SelectOpticalConfig")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.OpticalConfigId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.OpticalConfig.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("SelectOpticalConfig")).build();
                }
            }
        }
        return getSelectOpticalConfigMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalConfigId, context.ContextOuterClass.Empty> getDeleteOpticalConfigMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "DeleteOpticalConfig", requestType = context.ContextOuterClass.OpticalConfigId.class, responseType = context.ContextOuterClass.Empty.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalConfigId, context.ContextOuterClass.Empty> getDeleteOpticalConfigMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalConfigId, context.ContextOuterClass.Empty> getDeleteOpticalConfigMethod;
        if ((getDeleteOpticalConfigMethod = ContextServiceGrpc.getDeleteOpticalConfigMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getDeleteOpticalConfigMethod = ContextServiceGrpc.getDeleteOpticalConfigMethod) == null) {
                    ContextServiceGrpc.getDeleteOpticalConfigMethod = getDeleteOpticalConfigMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.OpticalConfigId, context.ContextOuterClass.Empty>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteOpticalConfig")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.OpticalConfigId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("DeleteOpticalConfig")).build();
                }
            }
        }
        return getDeleteOpticalConfigMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalConfig, context.ContextOuterClass.Empty> getDeleteOpticalChannelMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "DeleteOpticalChannel", requestType = context.ContextOuterClass.OpticalConfig.class, responseType = context.ContextOuterClass.Empty.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalConfig, context.ContextOuterClass.Empty> getDeleteOpticalChannelMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalConfig, context.ContextOuterClass.Empty> getDeleteOpticalChannelMethod;
        if ((getDeleteOpticalChannelMethod = ContextServiceGrpc.getDeleteOpticalChannelMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getDeleteOpticalChannelMethod = ContextServiceGrpc.getDeleteOpticalChannelMethod) == null) {
                    ContextServiceGrpc.getDeleteOpticalChannelMethod = getDeleteOpticalChannelMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.OpticalConfig, context.ContextOuterClass.Empty>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteOpticalChannel")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.OpticalConfig.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("DeleteOpticalChannel")).build();
                }
            }
        }
        return getDeleteOpticalChannelMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalLink, context.ContextOuterClass.Empty> getSetOpticalLinkMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "SetOpticalLink", requestType = context.ContextOuterClass.OpticalLink.class, responseType = context.ContextOuterClass.Empty.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalLink, context.ContextOuterClass.Empty> getSetOpticalLinkMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.OpticalLink, context.ContextOuterClass.Empty> getSetOpticalLinkMethod;
        if ((getSetOpticalLinkMethod = ContextServiceGrpc.getSetOpticalLinkMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getSetOpticalLinkMethod = ContextServiceGrpc.getSetOpticalLinkMethod) == null) {
                    ContextServiceGrpc.getSetOpticalLinkMethod = getSetOpticalLinkMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.OpticalLink, context.ContextOuterClass.Empty>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetOpticalLink")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.OpticalLink.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("SetOpticalLink")).build();
                }
            }
        }
        return getSetOpticalLinkMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.LinkId, context.ContextOuterClass.OpticalLink> getGetOpticalLinkMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetOpticalLink", requestType = context.ContextOuterClass.LinkId.class, responseType = context.ContextOuterClass.OpticalLink.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.LinkId, context.ContextOuterClass.OpticalLink> getGetOpticalLinkMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.LinkId, context.ContextOuterClass.OpticalLink> getGetOpticalLinkMethod;
        if ((getGetOpticalLinkMethod = ContextServiceGrpc.getGetOpticalLinkMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetOpticalLinkMethod = ContextServiceGrpc.getGetOpticalLinkMethod) == null) {
                    ContextServiceGrpc.getGetOpticalLinkMethod = getGetOpticalLinkMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.LinkId, context.ContextOuterClass.OpticalLink>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetOpticalLink")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.LinkId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.OpticalLink.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetOpticalLink")).build();
                }
            }
        }
        return getGetOpticalLinkMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.LinkId, context.ContextOuterClass.Empty> getDeleteOpticalLinkMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "DeleteOpticalLink", requestType = context.ContextOuterClass.LinkId.class, responseType = context.ContextOuterClass.Empty.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.LinkId, context.ContextOuterClass.Empty> getDeleteOpticalLinkMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.LinkId, context.ContextOuterClass.Empty> getDeleteOpticalLinkMethod;
        if ((getDeleteOpticalLinkMethod = ContextServiceGrpc.getDeleteOpticalLinkMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getDeleteOpticalLinkMethod = ContextServiceGrpc.getDeleteOpticalLinkMethod) == null) {
                    ContextServiceGrpc.getDeleteOpticalLinkMethod = getDeleteOpticalLinkMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.LinkId, context.ContextOuterClass.Empty>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteOpticalLink")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.LinkId.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("DeleteOpticalLink")).build();
                }
            }
        }
        return getDeleteOpticalLinkMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.OpticalLinkList> getGetOpticalLinkListMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "GetOpticalLinkList", requestType = context.ContextOuterClass.Empty.class, responseType = context.ContextOuterClass.OpticalLinkList.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.OpticalLinkList> getGetOpticalLinkListMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.Empty, context.ContextOuterClass.OpticalLinkList> getGetOpticalLinkListMethod;
        if ((getGetOpticalLinkListMethod = ContextServiceGrpc.getGetOpticalLinkListMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getGetOpticalLinkListMethod = ContextServiceGrpc.getGetOpticalLinkListMethod) == null) {
                    ContextServiceGrpc.getGetOpticalLinkListMethod = getGetOpticalLinkListMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.Empty, context.ContextOuterClass.OpticalLinkList>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetOpticalLinkList")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.OpticalLinkList.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("GetOpticalLinkList")).build();
                }
            }
        }
        return getGetOpticalLinkListMethod;
    }

    private static volatile io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceConfigRule, context.ContextOuterClass.Empty> getDeleteServiceConfigRuleMethod;

    @io.grpc.stub.annotations.RpcMethod(fullMethodName = SERVICE_NAME + '/' + "DeleteServiceConfigRule", requestType = context.ContextOuterClass.ServiceConfigRule.class, responseType = context.ContextOuterClass.Empty.class, methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
    public static io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceConfigRule, context.ContextOuterClass.Empty> getDeleteServiceConfigRuleMethod() {
        io.grpc.MethodDescriptor<context.ContextOuterClass.ServiceConfigRule, context.ContextOuterClass.Empty> getDeleteServiceConfigRuleMethod;
        if ((getDeleteServiceConfigRuleMethod = ContextServiceGrpc.getDeleteServiceConfigRuleMethod) == null) {
            synchronized (ContextServiceGrpc.class) {
                if ((getDeleteServiceConfigRuleMethod = ContextServiceGrpc.getDeleteServiceConfigRuleMethod) == null) {
                    ContextServiceGrpc.getDeleteServiceConfigRuleMethod = getDeleteServiceConfigRuleMethod = io.grpc.MethodDescriptor.<context.ContextOuterClass.ServiceConfigRule, context.ContextOuterClass.Empty>newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY).setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteServiceConfigRule")).setSampledToLocalTracing(true).setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.ServiceConfigRule.getDefaultInstance())).setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(context.ContextOuterClass.Empty.getDefaultInstance())).setSchemaDescriptor(new ContextServiceMethodDescriptorSupplier("DeleteServiceConfigRule")).build();
                }
            }
        }
        return getDeleteServiceConfigRuleMethod;
    }

    /**
     * Creates a new async stub that supports all call types for the service
     */
    public static ContextServiceStub newStub(io.grpc.Channel channel) {
        io.grpc.stub.AbstractStub.StubFactory<ContextServiceStub> factory = new io.grpc.stub.AbstractStub.StubFactory<ContextServiceStub>() {

            @java.lang.Override
            public ContextServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
                return new ContextServiceStub(channel, callOptions);
            }
        };
        return ContextServiceStub.newStub(factory, channel);
    }

    /**
     * Creates a new blocking-style stub that supports unary and streaming output calls on the service
     */
    public static ContextServiceBlockingStub newBlockingStub(io.grpc.Channel channel) {
        io.grpc.stub.AbstractStub.StubFactory<ContextServiceBlockingStub> factory = new io.grpc.stub.AbstractStub.StubFactory<ContextServiceBlockingStub>() {

            @java.lang.Override
            public ContextServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
                return new ContextServiceBlockingStub(channel, callOptions);
            }
        };
        return ContextServiceBlockingStub.newStub(factory, channel);
    }

    /**
     * Creates a new ListenableFuture-style stub that supports unary calls on the service
     */
    public static ContextServiceFutureStub newFutureStub(io.grpc.Channel channel) {
        io.grpc.stub.AbstractStub.StubFactory<ContextServiceFutureStub> factory = new io.grpc.stub.AbstractStub.StubFactory<ContextServiceFutureStub>() {

            @java.lang.Override
            public ContextServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
                return new ContextServiceFutureStub(channel, callOptions);
            }
        };
        return ContextServiceFutureStub.newStub(factory, channel);
    }

    /**
     */
    public interface AsyncService {

        /**
         */
        default void listContextIds(context.ContextOuterClass.Empty request, io.grpc.stub.StreamObserver<context.ContextOuterClass.ContextIdList> responseObserver) {
            io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListContextIdsMethod(), responseObserver);
        }

        /**
         */
        default void listContexts(context.ContextOuterClass.Empty request, io.grpc.stub.StreamObserver<context.ContextOuterClass.ContextList> responseObserver) {
            io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListContextsMethod(), responseObserver);
        }

        /**
         */
        default void getContext(context.ContextOuterClass.ContextId request, io.grpc.stub.StreamObserver<context.ContextOuterClass.Context> responseObserver) {
            io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetContextMethod(), responseObserver);
        }

        /**
         */
        default void setContext(context.ContextOuterClass.Context request, io.grpc.stub.StreamObserver<context.ContextOuterClass.ContextId> responseObserver) {
            io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetContextMethod(), responseObserver);
        }

        /**
         */
        default void removeContext(context.ContextOuterClass.ContextId request, io.grpc.stub.StreamObserver<context.ContextOuterClass.Empty> responseObserver) {
            io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRemoveContextMethod(), responseObserver);
        }

        /**
         */
        default void getContextEvents(context.ContextOuterClass.Empty request, io.grpc.stub.StreamObserver<context.ContextOuterClass.ContextEvent> responseObserver) {
            io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetContextEventsMethod(), responseObserver);
        }

        /**
         */