Esempio n. 1
0
 private static Checksum CreateChecksumFromStreamWriter(string kind, Action<ObjectWriter, CancellationToken> writer)
 {
     using (var stream = SerializableBytes.CreateWritableStream())
     using (var objectWriter = new StreamObjectWriter(stream))
     {
         objectWriter.WriteString(kind);
         writer(objectWriter, CancellationToken.None);
         return Checksum.Create(stream);
     }
 }
Esempio n. 2
0
        private static Checksum CreateChecksum(AnalyzerReference reference)
        {
            using (var stream = SerializableBytes.CreateWritableStream())
            using (var objectWriter = new StreamObjectWriter(stream))
            {
                objectWriter.WriteString(WellKnownSynchronizationKinds.AnalyzerReference);
                objectWriter.WriteString(reference.FullPath);

                return Checksum.Create(stream);
            }
        }
        private bool WriteIdentifierLocations(EsentStorage.Key key, Document document, VersionStamp version, SyntaxNode root, CancellationToken cancellationToken)
        {
            // delete any existing data
            if (!DeleteIdentifierLocations(key, cancellationToken))
            {
                return false;
            }

            var identifierMap = SharedPools.StringIgnoreCaseDictionary<int>().AllocateAndClear();

            Dictionary<string, List<int>> map = null;
            try
            {
                map = CreateIdentifierLocations(document, root, cancellationToken);

                // okay, write new data
                using (var accessor = _esentStorage.GetIdentifierLocationTableAccessor())
                {
                    // make sure I have all identifier ready before starting big insertion
                    int identifierId;
                    foreach (var identifier in map.Keys)
                    {
                        if (!TryGetUniqueIdentifierId(identifier, out identifierId))
                        {
                            return false;
                        }

                        identifierMap[identifier] = identifierId;
                    }

                    // save whole map
                    var uncommittedCount = 0;

                    foreach (var kv in map)
                    {
                        cancellationToken.ThrowIfCancellationRequested();

                        var identifier = kv.Key;
                        var positions = kv.Value;

                        if ((uncommittedCount + positions.Count) > FlushThreshold)
                        {
                            accessor.Flush();
                            uncommittedCount = 0;
                        }

                        accessor.PrepareBatchOneInsert();

                        identifierId = identifierMap[identifier];

                        using (var stream = accessor.GetWriteStream(key, identifierId))
                        using (var writer = new StreamObjectWriter(stream, cancellationToken: cancellationToken))
                        {
                            writer.WriteString(IdentifierSetSerializationVersion);
                            WriteList(writer, positions);
                        }

                        accessor.FinishBatchOneInsert();

                        uncommittedCount += positions.Count;
                    }

                    // save special identifier that indicates version for this document
                    if (!TrySaveIdentifierSetVersion(accessor, key, version))
                    {
                        return false;
                    }

                    return accessor.ApplyChanges();
                }
            }
            finally
            {
                SharedPools.StringIgnoreCaseDictionary<int>().ClearAndFree(identifierMap);
                Free(map);
            }
        }