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
|
// 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.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;
private final String commandLineForm;
@Nullable private final String unconvertedValue;
private final OptionInstanceOrigin origin;
public ParsedOptionDescription(
OptionDefinition optionDefinition,
String commandLineForm,
@Nullable String unconvertedValue,
OptionInstanceOrigin origin) {
this.optionDefinition = optionDefinition;
this.commandLineForm = commandLineForm;
this.unconvertedValue = unconvertedValue;
this.origin = origin;
}
public OptionDefinition getOptionDefinition() {
return optionDefinition;
}
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();
}
OptionDefinition getImplicitDependent() {
return origin.getImplicitDependent();
}
OptionDefinition 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() {
StringBuilder result = new StringBuilder();
result.append(optionDefinition);
result.append("set to '").append(unconvertedValue).append("' ");
result.append("with priority ").append(origin.getPriority());
if (origin.getSource() != null) {
result.append(" and source '").append(origin.getSource()).append("'");
}
return result.toString();
}
}
|
