ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-09 17:52:34 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge VS Code 1.31.1 (#4283)

Browse Source
This commit is contained in:
Matt Irvine
2019-03-15 13:09:45 -07:00
committed by GitHub
parent 7d31575149
commit 86bac90001
1716 changed files with 53308 additions and 48375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
src/vs/workbench/services/textmodelResolver/common/textModelResolverService.ts
View File

@@ -3,7 +3,6 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { TPromise } from 'vs/base/common/winjs.base';
import { URI } from 'vs/base/common/uri';
import { first } from 'vs/base/common/async';
import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
@@ -18,20 +17,20 @@ import { IUntitledEditorService } from 'vs/workbench/services/untitled/common/un
import { TextFileEditorModel } from 'vs/workbench/services/textfile/common/textFileEditorModel';
import { IFileService } from 'vs/platform/files/common/files';
class ResourceModelCollection extends ReferenceCollection<TPromise<ITextEditorModel>> {
class ResourceModelCollection extends ReferenceCollection<Promise<ITextEditorModel>> {
private providers: { [scheme: string]: ITextModelContentProvider[] } = Object.create(null);
private modelsToDispose = new Set<string>();
constructor(
@IInstantiationService private instantiationService: IInstantiationService,
@ITextFileService private textFileService: ITextFileService,
@IFileService private fileService: IFileService
@IInstantiationService private readonly instantiationService: IInstantiationService,
@ITextFileService private readonly textFileService: ITextFileService,
@IFileService private readonly fileService: IFileService
) {
super();
}
createReferencedObject(key: string, skipActivateProvider?: boolean): TPromise<ITextEditorModel> {
createReferencedObject(key: string, skipActivateProvider?: boolean): Promise<ITextEditorModel> {
this.modelsToDispose.delete(key);
const resource = URI.parse(key);
@@ -51,10 +50,10 @@ class ResourceModelCollection extends ReferenceCollection<TPromise<ITextEditorMo
return this.fileService.activateProvider(resource.scheme).then(() => this.createReferencedObject(key, true));
}
return TPromise.wrapError<ITextEditorModel>(new Error('resource is not available'));
return Promise.reject(new Error('resource is not available'));
}
destroyReferencedObject(key: string, modelPromise: TPromise<ITextEditorModel>): void {
destroyReferencedObject(key: string, modelPromise: Promise<ITextEditorModel>): void {
this.modelsToDispose.add(key);
modelPromise.then(model => {
@@ -97,14 +96,18 @@ class ResourceModelCollection extends ReferenceCollection<TPromise<ITextEditorMo
});
}
private resolveTextModelContent(key: string): TPromise<ITextModel> {
hasTextModelContentProvider(scheme: string): boolean {
return this.providers[scheme] !== undefined;
}
private resolveTextModelContent(key: string): Promise<ITextModel> {
const resource = URI.parse(key);
const providers = this.providers[resource.scheme] || [];
const factories = providers.map(p => () => TPromise.wrap(p.provideTextContent(resource)));
const factories = providers.map(p => () => Promise.resolve(p.provideTextContent(resource)));
return first(factories).then(model => {
if (!model) {
return TPromise.wrapError<ITextModel>(new Error('resource is not available'));
return Promise.reject(new Error('resource is not available'));
}
return model;
@@ -119,18 +122,18 @@ export class TextModelResolverService implements ITextModelService {
private resourceModelCollection: ResourceModelCollection;
constructor(
@IUntitledEditorService private untitledEditorService: IUntitledEditorService,
@IInstantiationService private instantiationService: IInstantiationService,
@IModelService private modelService: IModelService
@IUntitledEditorService private readonly untitledEditorService: IUntitledEditorService,
@IInstantiationService private readonly instantiationService: IInstantiationService,
@IModelService private readonly modelService: IModelService
) {
this.resourceModelCollection = instantiationService.createInstance(ResourceModelCollection);
}
createModelReference(resource: URI): TPromise<IReference<ITextEditorModel>> {
createModelReference(resource: URI): Promise<IReference<ITextEditorModel>> {
return this._createModelReference(resource);
}
private _createModelReference(resource: URI): TPromise<IReference<ITextEditorModel>> {
private _createModelReference(resource: URI): Promise<IReference<ITextEditorModel>> {
// Untitled Schema: go through cached input
if (resource.scheme === network.Schemas.untitled) {
@@ -142,10 +145,10 @@ export class TextModelResolverService implements ITextModelService {
const cachedModel = this.modelService.getModel(resource);
if (!cachedModel) {
return TPromise.wrapError<IReference<ITextEditorModel>>(new Error('Cant resolve inmemory resource'));
return Promise.reject(new Error('Cant resolve inmemory resource'));
}
return TPromise.as(new ImmortalReference(this.instantiationService.createInstance(ResourceEditorModel, resource)));
return Promise.resolve(new ImmortalReference(this.instantiationService.createInstance(ResourceEditorModel, resource)));
}
const ref = this.resourceModelCollection.acquire(resource.toString());
@@ -155,7 +158,7 @@ export class TextModelResolverService implements ITextModelService {
err => {
ref.dispose();
return TPromise.wrapError<IReference<ITextEditorModel>>(err);
return Promise.reject(err);
}
);
}
@@ -163,4 +166,8 @@ export class TextModelResolverService implements ITextModelService {
registerTextModelContentProvider(scheme: string, provider: ITextModelContentProvider): IDisposable {
return this.resourceModelCollection.registerTextModelContentProvider(scheme, provider);
}
hasTextModelContentProvider(scheme: string): boolean {
return this.resourceModelCollection.hasTextModelContentProvider(scheme);
}
}