public ProjectState WithRemovedHostDocument(HostDocument hostDocument) { if (hostDocument == null) { throw new ArgumentNullException(nameof(hostDocument)); } if (!Documents.ContainsKey(hostDocument.FilePath)) { return(this); } var documents = new Dictionary <string, DocumentState>(FilePathComparer.Instance); foreach (var kvp in Documents) { documents.Add(kvp.Key, kvp.Value); } documents.Remove(hostDocument.FilePath); var difference = ProjectDifference.DocumentRemoved; var state = new ProjectState(this, difference, HostProject, WorkspaceProject, documents); return(state); }
public ProjectState WithChangedHostDocument(HostDocument hostDocument, Func <Task <TextAndVersion> > loader) { if (hostDocument == null) { throw new ArgumentNullException(nameof(hostDocument)); } if (!Documents.ContainsKey(hostDocument.FilePath)) { return(this); } var documents = new Dictionary <string, DocumentState>(FilePathComparer.Instance); foreach (var kvp in Documents) { documents.Add(kvp.Key, kvp.Value); } if (documents.TryGetValue(hostDocument.FilePath, out var document)) { documents[hostDocument.FilePath] = document.WithTextLoader(loader); } var state = new ProjectState(this, ProjectDifference.DocumentChanged, HostProject, WorkspaceProject, documents); return(state); }
public ProjectState WithRemovedHostDocument(HostDocument hostDocument) { if (hostDocument == null) { throw new ArgumentNullException(nameof(hostDocument)); } if (!Documents.ContainsKey(hostDocument.FilePath)) { return(this); } var documents = Documents.Remove(hostDocument.FilePath); // First check if the updated document is an import - it's important that this happens // before updating the imports map. if (ImportsToRelatedDocuments.TryGetValue(hostDocument.TargetPath, out var relatedDocuments)) { foreach (var relatedDocument in relatedDocuments) { documents = documents.SetItem(relatedDocument, documents[relatedDocument].WithImportsChange()); } } // Compute the effect on the import map var importTargetPaths = GetImportDocumentTargetPaths(hostDocument.TargetPath); var importsToRelatedDocuments = RemoveFromImportsToRelatedDocuments(ImportsToRelatedDocuments, hostDocument, importTargetPaths); var state = new ProjectState(this, ProjectDifference.DocumentRemoved, HostProject, ProjectWorkspaceState, documents, importsToRelatedDocuments); return(state); }
public ProjectState WithAddedHostDocument(HostDocument hostDocument, Func <Task <TextAndVersion> > loader) { if (hostDocument == null) { throw new ArgumentNullException(nameof(hostDocument)); } if (loader == null) { throw new ArgumentNullException(nameof(loader)); } // Ignore attempts to 'add' a document with different data, we only // care about one, so it might as well be the one we have. if (Documents.ContainsKey(hostDocument.FilePath)) { return(this); } var documents = new Dictionary <string, DocumentState>(FilePathComparer.Instance); foreach (var kvp in Documents) { documents.Add(kvp.Key, kvp.Value); } documents.Add(hostDocument.FilePath, DocumentState.Create(Services, hostDocument, loader)); var difference = ProjectDifference.DocumentAdded; var state = new ProjectState(this, difference, HostProject, WorkspaceProject, documents); return(state); }
public Document GetDocument(GetDocument documentInfo) { return(new Document() { Id = documentInfo.Id, RawJsonValue = Documents.ContainsKey(documentInfo.Id) ? Documents[documentInfo.Id] : null, }); }
public async Task <IEnumerable <Document> > ListAsync(string container) { if (!Documents.ContainsKey(container)) { Documents[container] = (await DataSource.ListAsync(container).ConfigureAwait(false)).ToDictionary(d => d.Id, d => d); } return(Documents[container].Values.ToList().AsReadOnly()); }
public Task UpdateAsync(string container, string id, Document document) { if (!Documents.ContainsKey(container)) { Documents[container] = new Dictionary <string, Document>(); } Documents[container][id] = document; return(Task.CompletedTask); }
public Task DeleteAsync(string container, string id) { if (!Documents.ContainsKey(container)) { return(Task.CompletedTask); } Documents[container].Remove(id); return(Task.CompletedTask); }
public async Task DeleteAsync(string container, string id) { if (!Documents.ContainsKey(container)) { Documents[container] = (await DataSource.ListAsync(container).ConfigureAwait(false)).ToDictionary(d => d.Id, d => d); } await DataSource.DeleteAsync(container, id).ConfigureAwait(false); Documents[container].Remove(id); }
public async Task UpdateAsync(string container, string id, Document document) { if (!Documents.ContainsKey(container)) { Documents[container] = (await DataSource.ListAsync(container).ConfigureAwait(false)).ToDictionary(d => d.Id, d => d); } await DataSource.UpdateAsync(container, id, document).ConfigureAwait(false); Documents[container][id] = document; }
public Task Create(string container, Document document) { if (!Documents.ContainsKey(container)) { Documents[container] = new Dictionary <string, Document>(); } Documents[container][document.Id] = document; return(Task.CompletedTask); }
public async Task Create(string container, Document document) { await DataSource.CreateDocumentAsync(container, document).ConfigureAwait(false); if (!Documents.ContainsKey(container)) { Documents[container] = (await DataSource.ListAsync(container).ConfigureAwait(false)).ToDictionary(d => d.Id, d => d); } Documents[container][document.Id] = document; }
public bool UploadDocument(DocumentMetaData meta, object content) { if (!Documents.ContainsKey(meta.Name)) { var newDocument = DocumentFactory.CreateDocument(meta.Name); syncManager.SetContent(newDocument, content); Documents[meta.Name] = newDocument; return(true); } return(false); }
public async Task <Document> GetAsync(string container, string id) { if (!Documents.ContainsKey(container)) { Documents[container] = (await DataSource.ListAsync(container).ConfigureAwait(false)).ToDictionary(d => d.Id, d => d); } if (!Documents[container].ContainsKey(id)) { return(null); } return(Documents[container][id]); }
public Task <Document> GetAsync(string container, string id) { if (!Documents.ContainsKey(container)) { return(Task.FromResult <Document>(null)); } if (!Documents[container].ContainsKey(id)) { return(Task.FromResult <Document>(null)); } return(Task.FromResult(Documents[container][id])); }
/// <summary> /// Returns list of documents which have at least 1 similar term to passed document /// /// Usually this method is needed for getting list of docs for which we need perform tf-idf recalculations /// </summary> public List <Document> GetRelatedDocuments(Document document) { return(document.Tokens .SelectMany(t => { var tokenContext = _keyValueStorage.Get <TokenContext>(_tokenContextCacheKey(t)) ?? new TokenContext(); return tokenContext.DocumentIds; }) // Take unique document ids (because document can appear in multiply tokens) .Distinct() .Where(x => x != document.Id && Documents.ContainsKey(x)) .Select(x => Documents[x]) .ToList()); }
public bool CreateDocument(DocumentMetaData document) { if (!Documents.ContainsKey(document.Name)) { var newInstance = DocumentFactory.CreateDocument(document.Name); Documents[document.Name] = newInstance; var to = Clients.Where(c => c.Key != document.ClientId); Parallel.ForEach(to, c => c.Value.Client.NotifyDocumentCreated(document.Name)); return(true); } else { return(false); } }
private void ProcessMessage(OTMessage message) { foreach (var o in message.Content) { if (!Documents.ContainsKey(o.DocumentName)) { continue; } var operationContext = Documents[o.DocumentName]; Transform(o, operationContext); Execute(o, operationContext); operationContext.ServerMessages++; o.ExecutedAt = DateTime.Now; o.ClientMessages = this.clientMessages; o.ServerMessages = this.serverMessages; operationContext.Log.Add(o); } }
/// <summary> /// Trata el evento de cierre de un documento /// </summary> private bool TreatEventCloseForm(DockLayoutDocument document) { bool canClose = true; // Si es un documento, antes de cerrar se pregunta a la ventana principal if (document.Type == DockLayoutDocument.DocumentType.Document) { ClosingEventArgs args = new ClosingEventArgs(document); // Llama al manejador de eventos Closing?.Invoke(this, args); // Si no se ha cancelado, se puede cerrar canClose = !args.Cancel; } // Si se debe cerrar, se quita del diccionario if (canClose && Documents.ContainsKey(document.Id)) { Documents.Remove(document.Id); } // Devuelve el valor que indica si se puede cerrar el documento return(canClose); }
public ProjectState WithAddedHostDocument(HostDocument hostDocument, Func <Task <TextAndVersion> > loader) { if (hostDocument == null) { throw new ArgumentNullException(nameof(hostDocument)); } if (loader == null) { throw new ArgumentNullException(nameof(loader)); } // Ignore attempts to 'add' a document with different data, we only // care about one, so it might as well be the one we have. if (Documents.ContainsKey(hostDocument.FilePath)) { return(this); } var documents = Documents.Add(hostDocument.FilePath, DocumentState.Create(Services, hostDocument, loader)); // Compute the effect on the import map var importTargetPaths = GetImportDocumentTargetPaths(hostDocument.TargetPath); var importsToRelatedDocuments = AddToImportsToRelatedDocuments(ImportsToRelatedDocuments, hostDocument, importTargetPaths); // Now check if the updated document is an import - it's important this this happens after // updating the imports map. if (importsToRelatedDocuments.TryGetValue(hostDocument.TargetPath, out var relatedDocuments)) { foreach (var relatedDocument in relatedDocuments) { documents = documents.SetItem(relatedDocument, documents[relatedDocument].WithImportsChange()); } } var state = new ProjectState(this, ProjectDifference.DocumentAdded, HostProject, ProjectWorkspaceState, documents, importsToRelatedDocuments); return(state); }
public bool OpenDocument(DocumentMetaData document) { return(Documents.ContainsKey(document.Name)); }
/// <summary> /// Comprueba si existe un documento /// </summary> private bool ExistsDocument(string windowID) { return(Documents.ContainsKey(windowID)); }