zoekt: 45 files / 665 matches / 1.35ms neogrok: 20 files / 203 matches

github.com/sourcegraph/zoektinternal/e2e/examples/example.rb 4 matches | Ruby | №1

56 57 class Foo58 attr_accessor :bar59 attr_reader :baz

63 class Aliased64 def bar65 end66 67 alias_method :baz, :bar68 end

github.com/sourcegraph/zoektweb/templates.go 55 matches | Go | №2

94 95 "navbar": `96 <nav class="navbar navbar-default">97 <div class="container-fluid">98 <div class="navbar-header">99 <a class="navbar-brand" href="/">Zoekt</a>100

      <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar-collapse" aria-expanded="false">

101 Toggle navigation102 103 104 

github.com/sourcegraph/zoektdoc/query_syntax.md 11 matches | Markdown | №3

| `archived:`  | `a:`    | `yes` or `no`          | Filters archived repositories.                             | `archived:yes`                         |

| `case:`      | `c:`    | `yes`, `no`, or `auto` | Matches case-sensitive or insensitive text.                | `case:yes content:"Foo"`               |

| `content:`   | `c:`    | Text (string or regex) | Searches content of files.                                 | `content:"search term"`                |

| `public:`    |         | `yes` or `no`          | Filters public repositories.                               | `public:yes`                           |

| `regex:`     |         | Regex pattern          | Matches content using a regular expression.                | `regex:/foo.*bar/`                     |

| `repo:`      | `r:`    | Text (string or regex) | Filters repositories by name.                              | `repo:"github.com/user/project"`       |

102 #### Examples:103 - Match the string `foo"bar`:104 ```plaintext105 content:"foo\"bar"106 ```107 - Match the regex `foo.*bar`:108 ```plaintext109 content:/foo.*bar/

github.com/sourcegraph/zoektinternal/shards/shards.go 4 matches | Go | №4

484 //485 // For example if our query is (and (reposet foo bar) (content baz))486 // then at this point filtered is [foo bar] and q is the same. For each487 // shard indexData.simplify will simplify to (and true (content baz)) ->

github.com/isker/neogroksrc/routes/syntax/+page.svelte 43 matches | Svelte | №5

48 If your query contains no spaces, its behavior is pretty intuitive.49 <ExampleQuery query="foo" /> displays all matches for the regex50 <Expression>/foo/</Expression>. That query contains a single51 expression, namely a regex expression. (We'll introduce

54 55 But what about <ExampleQuery query="foo bar" />? This query has two56 expressions, which makes its behavior more complicated: it returns all57 matches for the regex <Expression>/foo/</Expression> or the regex <Expression58 >/bar/</Expression59 >, but only in files that have matches for both <Expression60 >/foo/</Expression61 > and62 <Expression>/bar/</Expression>.63 

github.com/sourcegraph/zoektinternal/e2e/examples/example.scala 5 matches | Scala | №6

25 * Index split on buckets per dialect in order to have a constant time26 * and low memory footprint to infer dialect for SymbolDefinition because27 * it's used in WorkspaceSymbolProvider

134 135 // Returns true if symbol is com/foo/Bar# and path is /com/foo/Bar.scala136 // Such symbols are "trivial" because their definition location can be computed

github.com/sourcegraph/zoektcmd/zoekt-sourcegraph-indexserver/json_schemas/XdsConfig.json 6 matches | JSON | №7

123 "type": "array",124

                    "description": "List of query parameter names to try to match. For example: [\"parent\", \"name\", \"resource.name\"] We extract all the specified query_parameters (case-sensitively).  If any are marked as \"required_match\" and are not present, this keybuilder fails to match.  If a given parameter appears multiple times (?foo=a\u0026foo=b) we will report it as a comma-separated string (foo=a,b)."

125 },

567 "title": "Name",568

            "description": "The names of the methods to which this configuration applies. - MethodConfig without names (empty list) will be skipped. - Each name entry must be unique across the entire ServiceConfig. - If the 'method' field is empty, this MethodConfig specifies the defaults   for all methods for the specified service. - If the 'service' field is empty, the 'method' field must be empty, and   this MethodConfig specifies the default for all methods (it's the default   config). When determining which MethodConfig to use for a given RPC, the most specific match wins. For example, let's say that the service config contains the following MethodConfig entries: method_config { name { } ... } method_config { name { service: \"MyService\" } ... } method_config { name { service: \"MyService\" method: \"Foo\" } ... } MyService/Foo will use the third entry, because it exactly matches the service and method name. MyService/Bar will use the second entry, because it provides the default for all methods of MyService. AnotherService/Baz will use the first entry, because it doesn't match the other two. In JSON representation, value \"\", value `null`, and not present are the same. The following are the same Name: - { \"service\": \"s\" } - { \"service\": \"s\", \"method\": null } - { \"service\": \"s\", \"method\": \"\" }"

569 },

github.com/sourcegraph/zoektcmd/zoekt-sourcegraph-indexserver/json_schemas/MethodConfig.json 3 matches | JSON | №8

121 "title": "Name",122

            "description": "The names of the methods to which this configuration applies. - MethodConfig without names (empty list) will be skipped. - Each name entry must be unique across the entire ServiceConfig. - If the 'method' field is empty, this MethodConfig specifies the defaults   for all methods for the specified service. - If the 'service' field is empty, the 'method' field must be empty, and   this MethodConfig specifies the default for all methods (it's the default   config). When determining which MethodConfig to use for a given RPC, the most specific match wins. For example, let's say that the service config contains the following MethodConfig entries: method_config { name { } ... } method_config { name { service: \"MyService\" } ... } method_config { name { service: \"MyService\" method: \"Foo\" } ... } MyService/Foo will use the third entry, because it exactly matches the service and method name. MyService/Bar will use the second entry, because it provides the default for all methods of MyService. AnotherService/Baz will use the first entry, because it doesn't match the other two. In JSON representation, value \"\", value `null`, and not present are the same. The following are the same Name: - { \"service\": \"s\" } - { \"service\": \"s\", \"method\": null } - { \"service\": \"s\", \"method\": \"\" }"

123 },

github.com/sourcegraph/zoektcmd/zoekt-sourcegraph-indexserver/json_schemas/GrpcLbConfig.json 6 matches | JSON | №9

113 "type": "array",114

                    "description": "List of query parameter names to try to match. For example: [\"parent\", \"name\", \"resource.name\"] We extract all the specified query_parameters (case-sensitively).  If any are marked as \"required_match\" and are not present, this keybuilder fails to match.  If a given parameter appears multiple times (?foo=a\u0026foo=b) we will report it as a comma-separated string (foo=a,b)."

115 },

532 "title": "Name",533

            "description": "The names of the methods to which this configuration applies. - MethodConfig without names (empty list) will be skipped. - Each name entry must be unique across the entire ServiceConfig. - If the 'method' field is empty, this MethodConfig specifies the defaults   for all methods for the specified service. - If the 'service' field is empty, the 'method' field must be empty, and   this MethodConfig specifies the default for all methods (it's the default   config). When determining which MethodConfig to use for a given RPC, the most specific match wins. For example, let's say that the service config contains the following MethodConfig entries: method_config { name { } ... } method_config { name { service: \"MyService\" } ... } method_config { name { service: \"MyService\" method: \"Foo\" } ... } MyService/Foo will use the third entry, because it exactly matches the service and method name. MyService/Bar will use the second entry, because it provides the default for all methods of MyService. AnotherService/Baz will use the first entry, because it doesn't match the other two. In JSON representation, value \"\", value `null`, and not present are the same. The following are the same Name: - { \"service\": \"s\" } - { \"service\": \"s\", \"method\": null } - { \"service\": \"s\", \"method\": \"\" }"

534 },

github.com/sourcegraph/zoektcmd/zoekt-sourcegraph-indexserver/json_schemas/ServiceConfig.json 6 matches | JSON | №10

136 "type": "array",137

                    "description": "List of query parameter names to try to match. For example: [\"parent\", \"name\", \"resource.name\"] We extract all the specified query_parameters (case-sensitively).  If any are marked as \"required_match\" and are not present, this keybuilder fails to match.  If a given parameter appears multiple times (?foo=a\u0026foo=b) we will report it as a comma-separated string (foo=a,b)."

138 },

580 "title": "Name",581

            "description": "The names of the methods to which this configuration applies. - MethodConfig without names (empty list) will be skipped. - Each name entry must be unique across the entire ServiceConfig. - If the 'method' field is empty, this MethodConfig specifies the defaults   for all methods for the specified service. - If the 'service' field is empty, the 'method' field must be empty, and   this MethodConfig specifies the default for all methods (it's the default   config). When determining which MethodConfig to use for a given RPC, the most specific match wins. For example, let's say that the service config contains the following MethodConfig entries: method_config { name { } ... } method_config { name { service: \"MyService\" } ... } method_config { name { service: \"MyService\" method: \"Foo\" } ... } MyService/Foo will use the third entry, because it exactly matches the service and method name. MyService/Bar will use the second entry, because it provides the default for all methods of MyService. AnotherService/Baz will use the first entry, because it doesn't match the other two. In JSON representation, value \"\", value `null`, and not present are the same. The following are the same Name: - { \"service\": \"s\" } - { \"service\": \"s\", \"method\": null } - { \"service\": \"s\", \"method\": \"\" }"

582 },

github.com/sourcegraph/zoektcmd/zoekt-sourcegraph-indexserver/json_schemas/LoadBalancingConfig.json 6 matches | JSON | №11

181 "type": "array",182

                    "description": "List of query parameter names to try to match. For example: [\"parent\", \"name\", \"resource.name\"] We extract all the specified query_parameters (case-sensitively).  If any are marked as \"required_match\" and are not present, this keybuilder fails to match.  If a given parameter appears multiple times (?foo=a\u0026foo=b) we will report it as a comma-separated string (foo=a,b)."

183 },

532 "title": "Name",533

            "description": "The names of the methods to which this configuration applies. - MethodConfig without names (empty list) will be skipped. - Each name entry must be unique across the entire ServiceConfig. - If the 'method' field is empty, this MethodConfig specifies the defaults   for all methods for the specified service. - If the 'service' field is empty, the 'method' field must be empty, and   this MethodConfig specifies the default for all methods (it's the default   config). When determining which MethodConfig to use for a given RPC, the most specific match wins. For example, let's say that the service config contains the following MethodConfig entries: method_config { name { } ... } method_config { name { service: \"MyService\" } ... } method_config { name { service: \"MyService\" method: \"Foo\" } ... } MyService/Foo will use the third entry, because it exactly matches the service and method name. MyService/Bar will use the second entry, because it provides the default for all methods of MyService. AnotherService/Baz will use the first entry, because it doesn't match the other two. In JSON representation, value \"\", value `null`, and not present are the same. The following are the same Name: - { \"service\": \"s\" } - { \"service\": \"s\", \"method\": null } - { \"service\": \"s\", \"method\": \"\" }"

534 },

github.com/sourcegraph/zoektcmd/zoekt-sourcegraph-indexserver/json_schemas/EdsLoadBalancingPolicyConfig.json 6 matches | JSON | №12

123 "type": "array",124

                    "description": "List of query parameter names to try to match. For example: [\"parent\", \"name\", \"resource.name\"] We extract all the specified query_parameters (case-sensitively).  If any are marked as \"required_match\" and are not present, this keybuilder fails to match.  If a given parameter appears multiple times (?foo=a\u0026foo=b) we will report it as a comma-separated string (foo=a,b)."

125 },

532 "title": "Name",533

            "description": "The names of the methods to which this configuration applies. - MethodConfig without names (empty list) will be skipped. - Each name entry must be unique across the entire ServiceConfig. - If the 'method' field is empty, this MethodConfig specifies the defaults   for all methods for the specified service. - If the 'service' field is empty, the 'method' field must be empty, and   this MethodConfig specifies the default for all methods (it's the default   config). When determining which MethodConfig to use for a given RPC, the most specific match wins. For example, let's say that the service config contains the following MethodConfig entries: method_config { name { } ... } method_config { name { service: \"MyService\" } ... } method_config { name { service: \"MyService\" method: \"Foo\" } ... } MyService/Foo will use the third entry, because it exactly matches the service and method name. MyService/Bar will use the second entry, because it provides the default for all methods of MyService. AnotherService/Baz will use the first entry, because it doesn't match the other two. In JSON representation, value \"\", value `null`, and not present are the same. The following are the same Name: - { \"service\": \"s\" } - { \"service\": \"s\", \"method\": null } - { \"service\": \"s\", \"method\": \"\" }"

534 },

github.com/sourcegraph/zoektcmd/zoekt-sourcegraph-indexserver/json_schemas/LrsLoadBalancingPolicyConfig.json 6 matches | JSON | №13

119 "type": "array",120

                    "description": "List of query parameter names to try to match. For example: [\"parent\", \"name\", \"resource.name\"] We extract all the specified query_parameters (case-sensitively).  If any are marked as \"required_match\" and are not present, this keybuilder fails to match.  If a given parameter appears multiple times (?foo=a\u0026foo=b) we will report it as a comma-separated string (foo=a,b)."

121 },

532 "title": "Name",533

            "description": "The names of the methods to which this configuration applies. - MethodConfig without names (empty list) will be skipped. - Each name entry must be unique across the entire ServiceConfig. - If the 'method' field is empty, this MethodConfig specifies the defaults   for all methods for the specified service. - If the 'service' field is empty, the 'method' field must be empty, and   this MethodConfig specifies the default for all methods (it's the default   config). When determining which MethodConfig to use for a given RPC, the most specific match wins. For example, let's say that the service config contains the following MethodConfig entries: method_config { name { } ... } method_config { name { service: \"MyService\" } ... } method_config { name { service: \"MyService\" method: \"Foo\" } ... } MyService/Foo will use the third entry, because it exactly matches the service and method name. MyService/Bar will use the second entry, because it provides the default for all methods of MyService. AnotherService/Baz will use the first entry, because it doesn't match the other two. In JSON representation, value \"\", value `null`, and not present are the same. The following are the same Name: - { \"service\": \"s\" } - { \"service\": \"s\", \"method\": null } - { \"service\": \"s\", \"method\": \"\" }"

534 },

github.com/sourcegraph/zoektcmd/zoekt-sourcegraph-indexserver/json_schemas/RlsLoadBalancingPolicyConfig.json 6 matches | JSON | №14

115 "type": "array",116

                    "description": "List of query parameter names to try to match. For example: [\"parent\", \"name\", \"resource.name\"] We extract all the specified query_parameters (case-sensitively).  If any are marked as \"required_match\" and are not present, this keybuilder fails to match.  If a given parameter appears multiple times (?foo=a\u0026foo=b) we will report it as a comma-separated string (foo=a,b)."

117 },

559 "title": "Name",560

            "description": "The names of the methods to which this configuration applies. - MethodConfig without names (empty list) will be skipped. - Each name entry must be unique across the entire ServiceConfig. - If the 'method' field is empty, this MethodConfig specifies the defaults   for all methods for the specified service. - If the 'service' field is empty, the 'method' field must be empty, and   this MethodConfig specifies the default for all methods (it's the default   config). When determining which MethodConfig to use for a given RPC, the most specific match wins. For example, let's say that the service config contains the following MethodConfig entries: method_config { name { } ... } method_config { name { service: \"MyService\" } ... } method_config { name { service: \"MyService\" method: \"Foo\" } ... } MyService/Foo will use the third entry, because it exactly matches the service and method name. MyService/Bar will use the second entry, because it provides the default for all methods of MyService. AnotherService/Baz will use the first entry, because it doesn't match the other two. In JSON representation, value \"\", value `null`, and not present are the same. The following are the same Name: - { \"service\": \"s\" } - { \"service\": \"s\", \"method\": null } - { \"service\": \"s\", \"method\": \"\" }"

561 },

github.com/sourcegraph/zoektcmd/zoekt-sourcegraph-indexserver/json_schemas/PriorityLoadBalancingPolicyConfig.json 6 matches | JSON | №15

110 "type": "array",111

                    "description": "List of query parameter names to try to match. For example: [\"parent\", \"name\", \"resource.name\"] We extract all the specified query_parameters (case-sensitively).  If any are marked as \"required_match\" and are not present, this keybuilder fails to match.  If a given parameter appears multiple times (?foo=a\u0026foo=b) we will report it as a comma-separated string (foo=a,b)."

112 },

554 "title": "Name",555

            "description": "The names of the methods to which this configuration applies. - MethodConfig without names (empty list) will be skipped. - Each name entry must be unique across the entire ServiceConfig. - If the 'method' field is empty, this MethodConfig specifies the defaults   for all methods for the specified service. - If the 'service' field is empty, the 'method' field must be empty, and   this MethodConfig specifies the default for all methods (it's the default   config). When determining which MethodConfig to use for a given RPC, the most specific match wins. For example, let's say that the service config contains the following MethodConfig entries: method_config { name { } ... } method_config { name { service: \"MyService\" } ... } method_config { name { service: \"MyService\" method: \"Foo\" } ... } MyService/Foo will use the third entry, because it exactly matches the service and method name. MyService/Bar will use the second entry, because it provides the default for all methods of MyService. AnotherService/Baz will use the first entry, because it doesn't match the other two. In JSON representation, value \"\", value `null`, and not present are the same. The following are the same Name: - { \"service\": \"s\" } - { \"service\": \"s\", \"method\": null } - { \"service\": \"s\", \"method\": \"\" }"

556 },

github.com/sourcegraph/zoektcmd/zoekt-sourcegraph-indexserver/json_schemas/OutlierDetectionLoadBalancingConfig.json 6 matches | JSON | №16

136 "type": "array",137

                    "description": "List of query parameter names to try to match. For example: [\"parent\", \"name\", \"resource.name\"] We extract all the specified query_parameters (case-sensitively).  If any are marked as \"required_match\" and are not present, this keybuilder fails to match.  If a given parameter appears multiple times (?foo=a\u0026foo=b) we will report it as a comma-separated string (foo=a,b)."

138 },

580 "title": "Name",581

            "description": "The names of the methods to which this configuration applies. - MethodConfig without names (empty list) will be skipped. - Each name entry must be unique across the entire ServiceConfig. - If the 'method' field is empty, this MethodConfig specifies the defaults   for all methods for the specified service. - If the 'service' field is empty, the 'method' field must be empty, and   this MethodConfig specifies the default for all methods (it's the default   config). When determining which MethodConfig to use for a given RPC, the most specific match wins. For example, let's say that the service config contains the following MethodConfig entries: method_config { name { } ... } method_config { name { service: \"MyService\" } ... } method_config { name { service: \"MyService\" method: \"Foo\" } ... } MyService/Foo will use the third entry, because it exactly matches the service and method name. MyService/Bar will use the second entry, because it provides the default for all methods of MyService. AnotherService/Baz will use the first entry, because it doesn't match the other two. In JSON representation, value \"\", value `null`, and not present are the same. The following are the same Name: - { \"service\": \"s\" } - { \"service\": \"s\", \"method\": null } - { \"service\": \"s\", \"method\": \"\" }"

582 },

github.com/sourcegraph/zoektcmd/zoekt-sourcegraph-indexserver/json_schemas/OverrideHostLoadBalancingPolicyConfig.json 6 matches | JSON | №17

116 "type": "array",117

                    "description": "List of query parameter names to try to match. For example: [\"parent\", \"name\", \"resource.name\"] We extract all the specified query_parameters (case-sensitively).  If any are marked as \"required_match\" and are not present, this keybuilder fails to match.  If a given parameter appears multiple times (?foo=a\u0026foo=b) we will report it as a comma-separated string (foo=a,b)."

118 },

560 "title": "Name",561

            "description": "The names of the methods to which this configuration applies. - MethodConfig without names (empty list) will be skipped. - Each name entry must be unique across the entire ServiceConfig. - If the 'method' field is empty, this MethodConfig specifies the defaults   for all methods for the specified service. - If the 'service' field is empty, the 'method' field must be empty, and   this MethodConfig specifies the default for all methods (it's the default   config). When determining which MethodConfig to use for a given RPC, the most specific match wins. For example, let's say that the service config contains the following MethodConfig entries: method_config { name { } ... } method_config { name { service: \"MyService\" } ... } method_config { name { service: \"MyService\" method: \"Foo\" } ... } MyService/Foo will use the third entry, because it exactly matches the service and method name. MyService/Bar will use the second entry, because it provides the default for all methods of MyService. AnotherService/Baz will use the first entry, because it doesn't match the other two. In JSON representation, value \"\", value `null`, and not present are the same. The following are the same Name: - { \"service\": \"s\" } - { \"service\": \"s\", \"method\": null } - { \"service\": \"s\", \"method\": \"\" }"

562 },

github.com/sourcegraph/zoektcmd/zoekt-sourcegraph-indexserver/json_schemas/WeightedTargetLoadBalancingPolicyConfig.json 6 matches | JSON | №18

103 "type": "array",104

                    "description": "List of query parameter names to try to match. For example: [\"parent\", \"name\", \"resource.name\"] We extract all the specified query_parameters (case-sensitively).  If any are marked as \"required_match\" and are not present, this keybuilder fails to match.  If a given parameter appears multiple times (?foo=a\u0026foo=b) we will report it as a comma-separated string (foo=a,b)."

105 },

547 "title": "Name",548

            "description": "The names of the methods to which this configuration applies. - MethodConfig without names (empty list) will be skipped. - Each name entry must be unique across the entire ServiceConfig. - If the 'method' field is empty, this MethodConfig specifies the defaults   for all methods for the specified service. - If the 'service' field is empty, the 'method' field must be empty, and   this MethodConfig specifies the default for all methods (it's the default   config). When determining which MethodConfig to use for a given RPC, the most specific match wins. For example, let's say that the service config contains the following MethodConfig entries: method_config { name { } ... } method_config { name { service: \"MyService\" } ... } method_config { name { service: \"MyService\" method: \"Foo\" } ... } MyService/Foo will use the third entry, because it exactly matches the service and method name. MyService/Bar will use the second entry, because it provides the default for all methods of MyService. AnotherService/Baz will use the first entry, because it doesn't match the other two. In JSON representation, value \"\", value `null`, and not present are the same. The following are the same Name: - { \"service\": \"s\" } - { \"service\": \"s\", \"method\": null } - { \"service\": \"s\", \"method\": \"\" }"

549 },

github.com/sourcegraph/zoektcmd/zoekt-sourcegraph-indexserver/json_schemas/XdsClusterImplLoadBalancingPolicyConfig.json 6 matches | JSON | №19

132 "type": "array",133

                    "description": "List of query parameter names to try to match. For example: [\"parent\", \"name\", \"resource.name\"] We extract all the specified query_parameters (case-sensitively).  If any are marked as \"required_match\" and are not present, this keybuilder fails to match.  If a given parameter appears multiple times (?foo=a\u0026foo=b) we will report it as a comma-separated string (foo=a,b)."

134 },

576 "title": "Name",577

            "description": "The names of the methods to which this configuration applies. - MethodConfig without names (empty list) will be skipped. - Each name entry must be unique across the entire ServiceConfig. - If the 'method' field is empty, this MethodConfig specifies the defaults   for all methods for the specified service. - If the 'service' field is empty, the 'method' field must be empty, and   this MethodConfig specifies the default for all methods (it's the default   config). When determining which MethodConfig to use for a given RPC, the most specific match wins. For example, let's say that the service config contains the following MethodConfig entries: method_config { name { } ... } method_config { name { service: \"MyService\" } ... } method_config { name { service: \"MyService\" method: \"Foo\" } ... } MyService/Foo will use the third entry, because it exactly matches the service and method name. MyService/Bar will use the second entry, because it provides the default for all methods of MyService. AnotherService/Baz will use the first entry, because it doesn't match the other two. In JSON representation, value \"\", value `null`, and not present are the same. The following are the same Name: - { \"service\": \"s\" } - { \"service\": \"s\", \"method\": null } - { \"service\": \"s\", \"method\": \"\" }"

578 },

github.com/sourcegraph/zoektcmd/zoekt-sourcegraph-indexserver/json_schemas/XdsWrrLocalityLoadBalancingPolicyConfig.json 6 matches | JSON | №20

102 "type": "array",103

                    "description": "List of query parameter names to try to match. For example: [\"parent\", \"name\", \"resource.name\"] We extract all the specified query_parameters (case-sensitively).  If any are marked as \"required_match\" and are not present, this keybuilder fails to match.  If a given parameter appears multiple times (?foo=a\u0026foo=b) we will report it as a comma-separated string (foo=a,b)."

104 },

546 "title": "Name",547

            "description": "The names of the methods to which this configuration applies. - MethodConfig without names (empty list) will be skipped. - Each name entry must be unique across the entire ServiceConfig. - If the 'method' field is empty, this MethodConfig specifies the defaults   for all methods for the specified service. - If the 'service' field is empty, the 'method' field must be empty, and   this MethodConfig specifies the default for all methods (it's the default   config). When determining which MethodConfig to use for a given RPC, the most specific match wins. For example, let's say that the service config contains the following MethodConfig entries: method_config { name { } ... } method_config { name { service: \"MyService\" } ... } method_config { name { service: \"MyService\" method: \"Foo\" } ... } MyService/Foo will use the third entry, because it exactly matches the service and method name. MyService/Bar will use the second entry, because it provides the default for all methods of MyService. AnotherService/Baz will use the first entry, because it doesn't match the other two. In JSON representation, value \"\", value `null`, and not present are the same. The following are the same Name: - { \"service\": \"s\" } - { \"service\": \"s\", \"method\": null } - { \"service\": \"s\", \"method\": \"\" }"

548 },