in patched-vscode/src/vs/platform/configuration/common/configurationModels.ts [450:735]
identifiers: overrideIdentifiersFromKey(key),
keys: Object.keys(overrideRaw),
contents: toValuesTree(overrideRaw, conflictReporter)
});
}
}
return overrides;
}
}
export class UserSettings extends Disposable {
private readonly parser: ConfigurationModelParser;
protected readonly _onDidChange: Emitter<void> = this._register(new Emitter<void>());
readonly onDidChange: Event<void> = this._onDidChange.event;
constructor(
private readonly userSettingsResource: URI,
protected parseOptions: ConfigurationParseOptions,
extUri: IExtUri,
private readonly fileService: IFileService,
private readonly logService: ILogService,
) {
super();
this.parser = new ConfigurationModelParser(this.userSettingsResource.toString(), logService);
this._register(this.fileService.watch(extUri.dirname(this.userSettingsResource)));
// Also listen to the resource incase the resource is a symlink - https://github.com/microsoft/vscode/issues/118134
this._register(this.fileService.watch(this.userSettingsResource));
this._register(Event.any(
Event.filter(this.fileService.onDidFilesChange, e => e.contains(this.userSettingsResource)),
Event.filter(this.fileService.onDidRunOperation, e => (e.isOperation(FileOperation.CREATE) || e.isOperation(FileOperation.COPY) || e.isOperation(FileOperation.DELETE) || e.isOperation(FileOperation.WRITE)) && extUri.isEqual(e.resource, userSettingsResource))
)(() => this._onDidChange.fire()));
}
async loadConfiguration(): Promise<ConfigurationModel> {
try {
const content = await this.fileService.readFile(this.userSettingsResource);
this.parser.parse(content.value.toString() || '{}', this.parseOptions);
return this.parser.configurationModel;
} catch (e) {
return ConfigurationModel.createEmptyModel(this.logService);
}
}
reparse(parseOptions?: ConfigurationParseOptions): ConfigurationModel {
if (parseOptions) {
this.parseOptions = parseOptions;
}
this.parser.reparse(this.parseOptions);
return this.parser.configurationModel;
}
getRestrictedSettings(): string[] {
return this.parser.restrictedConfigurations;
}
}
class ConfigurationInspectValue<V> implements IConfigurationValue<V> {
constructor(
private readonly key: string,
private readonly overrides: IConfigurationOverrides,
private readonly _value: V | undefined,
readonly overrideIdentifiers: string[] | undefined,
private readonly defaultConfiguration: ConfigurationModel,
private readonly policyConfiguration: ConfigurationModel | undefined,
private readonly applicationConfiguration: ConfigurationModel | undefined,
private readonly userConfiguration: ConfigurationModel,
private readonly localUserConfiguration: ConfigurationModel,
private readonly remoteUserConfiguration: ConfigurationModel,
private readonly workspaceConfiguration: ConfigurationModel | undefined,
private readonly folderConfigurationModel: ConfigurationModel | undefined,
private readonly memoryConfigurationModel: ConfigurationModel
) {
}
get value(): V | undefined {
return freeze(this._value);
}
private toInspectValue(inspectValue: IInspectValue<V> | undefined | null): IInspectValue<V> | undefined {
return inspectValue?.value !== undefined || inspectValue?.override !== undefined || inspectValue?.overrides !== undefined ? inspectValue : undefined;
}
private _defaultInspectValue: InspectValue<V> | undefined;
private get defaultInspectValue(): InspectValue<V> {
if (!this._defaultInspectValue) {
this._defaultInspectValue = this.defaultConfiguration.inspect<V>(this.key, this.overrides.overrideIdentifier);
}
return this._defaultInspectValue;
}
get defaultValue(): V | undefined {
return this.defaultInspectValue.merged;
}
get default(): IInspectValue<V> | undefined {
return this.toInspectValue(this.defaultInspectValue);
}
private _policyInspectValue: InspectValue<V> | undefined | null;
private get policyInspectValue(): InspectValue<V> | null {
if (this._policyInspectValue === undefined) {
this._policyInspectValue = this.policyConfiguration ? this.policyConfiguration.inspect<V>(this.key) : null;
}
return this._policyInspectValue;
}
get policyValue(): V | undefined {
return this.policyInspectValue?.merged;
}
get policy(): IInspectValue<V> | undefined {
return this.policyInspectValue?.value !== undefined ? { value: this.policyInspectValue.value } : undefined;
}
private _applicationInspectValue: InspectValue<V> | undefined | null;
private get applicationInspectValue(): InspectValue<V> | null {
if (this._applicationInspectValue === undefined) {
this._applicationInspectValue = this.applicationConfiguration ? this.applicationConfiguration.inspect<V>(this.key) : null;
}
return this._applicationInspectValue;
}
get applicationValue(): V | undefined {
return this.applicationInspectValue?.merged;
}
get application(): IInspectValue<V> | undefined {
return this.toInspectValue(this.applicationInspectValue);
}
private _userInspectValue: InspectValue<V> | undefined;
private get userInspectValue(): InspectValue<V> {
if (!this._userInspectValue) {
this._userInspectValue = this.userConfiguration.inspect<V>(this.key, this.overrides.overrideIdentifier);
}
return this._userInspectValue;
}
get userValue(): V | undefined {
return this.userInspectValue.merged;
}
get user(): IInspectValue<V> | undefined {
return this.toInspectValue(this.userInspectValue);
}
private _userLocalInspectValue: InspectValue<V> | undefined;
private get userLocalInspectValue(): InspectValue<V> {
if (!this._userLocalInspectValue) {
this._userLocalInspectValue = this.localUserConfiguration.inspect<V>(this.key, this.overrides.overrideIdentifier);
}
return this._userLocalInspectValue;
}
get userLocalValue(): V | undefined {
return this.userLocalInspectValue.merged;
}
get userLocal(): IInspectValue<V> | undefined {
return this.toInspectValue(this.userLocalInspectValue);
}
private _userRemoteInspectValue: InspectValue<V> | undefined;
private get userRemoteInspectValue(): InspectValue<V> {
if (!this._userRemoteInspectValue) {
this._userRemoteInspectValue = this.remoteUserConfiguration.inspect<V>(this.key, this.overrides.overrideIdentifier);
}
return this._userRemoteInspectValue;
}
get userRemoteValue(): V | undefined {
return this.userRemoteInspectValue.merged;
}
get userRemote(): IInspectValue<V> | undefined {
return this.toInspectValue(this.userRemoteInspectValue);
}
private _workspaceInspectValue: InspectValue<V> | undefined | null;
private get workspaceInspectValue(): InspectValue<V> | null {
if (this._workspaceInspectValue === undefined) {
this._workspaceInspectValue = this.workspaceConfiguration ? this.workspaceConfiguration.inspect<V>(this.key, this.overrides.overrideIdentifier) : null;
}
return this._workspaceInspectValue;
}
get workspaceValue(): V | undefined {
return this.workspaceInspectValue?.merged;
}
get workspace(): IInspectValue<V> | undefined {
return this.toInspectValue(this.workspaceInspectValue);
}
private _workspaceFolderInspectValue: InspectValue<V> | undefined | null;
private get workspaceFolderInspectValue(): InspectValue<V> | null {
if (this._workspaceFolderInspectValue === undefined) {
this._workspaceFolderInspectValue = this.folderConfigurationModel ? this.folderConfigurationModel.inspect<V>(this.key, this.overrides.overrideIdentifier) : null;
}
return this._workspaceFolderInspectValue;
}
get workspaceFolderValue(): V | undefined {
return this.workspaceFolderInspectValue?.merged;
}
get workspaceFolder(): IInspectValue<V> | undefined {
return this.toInspectValue(this.workspaceFolderInspectValue);
}
private _memoryInspectValue: InspectValue<V> | undefined;
private get memoryInspectValue(): InspectValue<V> {
if (this._memoryInspectValue === undefined) {
this._memoryInspectValue = this.memoryConfigurationModel.inspect<V>(this.key, this.overrides.overrideIdentifier);
}
return this._memoryInspectValue;
}
get memoryValue(): V | undefined {
return this.memoryInspectValue.merged;
}
get memory(): IInspectValue<V> | undefined {
return this.toInspectValue(this.memoryInspectValue);
}
}
export class Configuration {
private _workspaceConsolidatedConfiguration: ConfigurationModel | null = null;
private _foldersConsolidatedConfigurations = new ResourceMap<ConfigurationModel>();
constructor(
private _defaultConfiguration: ConfigurationModel,
private _policyConfiguration: ConfigurationModel,
private _applicationConfiguration: ConfigurationModel,
private _localUserConfiguration: ConfigurationModel,
private _remoteUserConfiguration: ConfigurationModel,
private _workspaceConfiguration: ConfigurationModel,
private _folderConfigurations: ResourceMap<ConfigurationModel>,
private _memoryConfiguration: ConfigurationModel,
private _memoryConfigurationByResource: ResourceMap<ConfigurationModel>,
private readonly logService: ILogService
) {
}
getValue(section: string | undefined, overrides: IConfigurationOverrides, workspace: Workspace | undefined): any {
const consolidateConfigurationModel = this.getConsolidatedConfigurationModel(section, overrides, workspace);
return consolidateConfigurationModel.getValue(section);
}
updateValue(key: string, value: any, overrides: IConfigurationUpdateOverrides = {}): void {
let memoryConfiguration: ConfigurationModel | undefined;
if (overrides.resource) {
memoryConfiguration = this._memoryConfigurationByResource.get(overrides.resource);
if (!memoryConfiguration) {
memoryConfiguration = ConfigurationModel.createEmptyModel(this.logService);
this._memoryConfigurationByResource.set(overrides.resource, memoryConfiguration);
}
} else {
memoryConfiguration = this._memoryConfiguration;
}
if (value === undefined) {
memoryConfiguration.removeValue(key);
} else {
memoryConfiguration.setValue(key, value);
}
if (!overrides.resource) {
this._workspaceConsolidatedConfiguration = null;
}
}
inspect<C>(key: string, overrides: IConfigurationOverrides, workspace: Workspace | undefined): IConfigurationValue<C> {
const consolidateConfigurationModel = this.getConsolidatedConfigurationModel(key, overrides, workspace);
const folderConfigurationModel = this.getFolderConfigurationModelForResource(overrides.resource, workspace);
const memoryConfigurationModel = overrides.resource ? this._memoryConfigurationByResource.get(overrides.resource) || this._memoryConfiguration : this._memoryConfiguration;
const overrideIdentifiers = new Set<string>();
for (const override of consolidateConfigurationModel.overrides) {
for (const overrideIdentifier of override.identifiers) {
if (consolidateConfigurationModel.getOverrideValue(key, overrideIdentifier) !== undefined) {