ContextServiceGrpc.java

package context;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.38.1)",
    comments = "Source: context.proto")
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.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()))