1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
// Copyright 2017 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.common.options;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import java.util.function.Function;
import javax.annotation.Nullable;
/**
* The representation of a parsed option instance.
*
* <p>An option instance is distinct from the final value of an option, as multiple instances
* provide values may be overridden or combined in some way.
*/
public final class ParsedOptionDescription {
private final OptionDefinition optionDefinition;
@Nullable private final String commandLineForm;
@Nullable private final String unconvertedValue;
private final OptionInstanceOrigin origin;
private ParsedOptionDescription(
OptionDefinition optionDefinition,
@Nullable String commandLineForm,
@Nullable String unconvertedValue,
OptionInstanceOrigin origin) {
this.optionDefinition = Preconditions.checkNotNull(optionDefinition);
this.commandLineForm = commandLineForm;
this.unconvertedValue = unconvertedValue;
this.origin = Preconditions.checkNotNull(origin);
}
static ParsedOptionDescription newParsedOptionDescription(
OptionDefinition optionDefinition,
String commandLineForm,
@Nullable String unconvertedValue,
OptionInstanceOrigin origin) {
// An actual ParsedOptionDescription should always have a form in which it was parsed, but some
// options, such as expansion options, legitimately have no value.
return new ParsedOptionDescription(
optionDefinition,
Preconditions.checkNotNull(commandLineForm),
unconvertedValue,
origin);
}
/**
* This factory should be used when there is no actual parsed option, since in those cases we do
* not have an original value or form that the option took.
*/
static ParsedOptionDescription newDummyInstance(
OptionDefinition optionDefinition, OptionInstanceOrigin origin) {
return new ParsedOptionDescription(optionDefinition, null, null, origin);
}
public OptionDefinition getOptionDefinition() {
return optionDefinition;
}
@Nullable
public String getCommandLineForm() {
return commandLineForm;
}
public String getCanonicalForm() {
return getCanonicalFormWithValueEscaper(s -> s);
}
public String getCanonicalFormWithValueEscaper(Function<String, String> escapingFunction) {
// For boolean flags (note that here we do not check for TriState flags, only flags with actual
// boolean values, so that we know the return type of getConvertedValue), use the --[no]flag
// form for the canonical value.
if (optionDefinition.getType().equals(boolean.class)) {
try {
return ((boolean) getConvertedValue() ? "--" : "--no") + optionDefinition.getOptionName();
} catch (OptionsParsingException e) {
throw new RuntimeException("Unexpected parsing exception", e);
}
} else {
String optionString = "--" + optionDefinition.getOptionName();
if (unconvertedValue != null) { // Can be null for Void options.
optionString += "=" + escapingFunction.apply(unconvertedValue);
}
return optionString;
}
}
@Deprecated
// TODO(b/65646296) Once external dependencies are cleaned up, use getCanonicalForm()
String getDeprecatedCanonicalForm() {
String value = unconvertedValue;
// For boolean flags (note that here we do not check for TriState flags, only flags with actual
// boolean values, so that we know the return type of getConvertedValue), set them all to 1 or
// 0, instead of keeping the wide variety of values we accept in their original form.
if (optionDefinition.getType().equals(boolean.class)) {
try {
value = (boolean) getConvertedValue() ? "1" : "0";
} catch (OptionsParsingException e) {
throw new RuntimeException("Unexpected parsing exception", e);
}
}
return String.format("--%s=%s", optionDefinition.getOptionName(), value);
}
public boolean isBooleanOption() {
return optionDefinition.getType().equals(boolean.class);
}
private OptionDocumentationCategory documentationCategory() {
return optionDefinition.getDocumentationCategory();
}
private ImmutableList<OptionMetadataTag> metadataTags() {
return ImmutableList.copyOf(optionDefinition.getOptionMetadataTags());
}
public boolean isDocumented() {
return documentationCategory() != OptionDocumentationCategory.UNDOCUMENTED && !isHidden();
}
public boolean isHidden() {
ImmutableList<OptionMetadataTag> tags = metadataTags();
return tags.contains(OptionMetadataTag.HIDDEN) || tags.contains(OptionMetadataTag.INTERNAL);
}
public String getUnconvertedValue() {
return unconvertedValue;
}
public OptionInstanceOrigin getOrigin() {
return origin;
}
public OptionPriority getPriority() {
return origin.getPriority();
}
public String getSource() {
return origin.getSource();
}
ParsedOptionDescription getImplicitDependent() {
return origin.getImplicitDependent();
}
ParsedOptionDescription getExpandedFrom() {
return origin.getExpandedFrom();
}
public boolean isExplicit() {
return origin.getExpandedFrom() == null && origin.getImplicitDependent() == null;
}
public Object getConvertedValue() throws OptionsParsingException {
Converter<?> converter = optionDefinition.getConverter();
try {
return converter.convert(unconvertedValue);
} catch (OptionsParsingException e) {
// The converter doesn't know the option name, so we supply it here by re-throwing:
throw new OptionsParsingException(
String.format("While parsing option %s: %s", commandLineForm, e.getMessage()), e);
}
}
@Override
public String toString() {
// Check that a dummy value-less option instance does not output all the default information.
if (commandLineForm == null) {
return optionDefinition.toString();
}
String source = origin.getSource();
return String.format(
"option '%s'%s",
commandLineForm, source == null ? "" : String.format(" (source %s)", source));
}
}
|
