public GitPackFile(IFileSystem fileSystem, string filename, ICompressionStrategy compression, GitPackIndex index, IDeltaDecoder delta) { if (fileSystem == null) { throw new ArgumentNullException("fileSystem"); } if (String.IsNullOrEmpty(filename)) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "filename"), "filename"); } if (compression == null) { throw new ArgumentNullException("compression"); } if (index == null) { throw new ArgumentNullException("index"); } if (delta == null) { throw new ArgumentNullException("delta"); } FileSystem = fileSystem; PackFileName = filename; Compression = compression; Index = index; Delta = delta; }
public void TestSelectionStrategy() { var data = new byte[TestSize]; for (int i = 0; i < TestSize; i++) { data[i] = (byte)i; } var compressors = new ICompressionStrategy[TestSize]; for (int i = 0; i < TestSize; i++) { compressors[i] = new MockStrategy((byte)i); } var strategy = new BruteCompressionStrategy(compressors); var memStream = new MemoryStream(); var compressingStream = new BruteCompressingStream(new BinaryWriter(memStream), 1, strategy); compressingStream.Write(data, 0, TestSize); compressingStream.Flush(); Assert.AreEqual(memStream.Position, TestSize * 4); Console.WriteLine("Compressed {0} to {1} ({2}%)", TestSize, memStream.Position, memStream.Position * 100 / TestSize); }
IKeyValueDB CreateKeyValueDB(IFileCollection fileCollection, ICompressionStrategy compressionStrategy = null) { if (fileCollection == null) { switch (_kvType) { case KVType.Managed: return(new InMemoryKeyValueDB()); default: throw new NotImplementedException(); } } switch (_kvType) { case KVType.Managed: if (compressionStrategy == null) { return(new KeyValueDB(fileCollection)); } return(new KeyValueDB(fileCollection, compressionStrategy)); case KVType.BTree: if (compressionStrategy == null) { return(new BTreeKeyValueDB(fileCollection)); } return(new BTreeKeyValueDB(fileCollection, compressionStrategy)); default: throw new NotImplementedException(); } }
public GitLooseFilesDictionary(IFileSystem root, ICompressionStrategy compression) { if (root == null) { throw new ArgumentNullException("root"); } if (compression == null) { throw new ArgumentNullException("compression"); } Root = root; Compression = compression; }
public ReadOnlyEventStore(IEventFileStorage file, ITypeSerializersMapping mapping, ICompressionStrategy compressionStrategy) { File = file; Mapping = mapping; CompressionStrategy = compressionStrategy; EndBufferPosition = ulong.MaxValue; MaxBlockSize = Math.Min(File.MaxBlockSize, 0x1000000); // For Length there is only 3 bytes so maximum could be less if (MaxBlockSize < FirstReadAhead) throw new ArgumentException("file.MaxBlockSize is less than FirstReadAhead"); }
public Compression(ICompressionStrategy compressionStrategy, Enums.CompressionAlgorithms algorithms, Data.Structure.CompressingSpecificationStructure specificationStructure) { CompressionStrategy = compressionStrategy; this.algorithms = algorithms; this.CompressingSpecification = specificationStructure; }
public TestableGitPackFile( IFileSystem fileSystem, string fileName, ICompressionStrategy compression, Mock <GitPackIndex> index, IDeltaDecoder delta) : base(fileSystem, fileName, compression, index.Object, delta) { MockIndex = index; }
public Dispatcher(ICompressionStrategy compressionStrategy, IFileFormatter fileFormatter) { _compressionStrategy = compressionStrategy; _fileFormatter = fileFormatter; _workers = new Worker[Environment.ProcessorCount]; for (int i = 0; i < _workers.Length; i++) { _workers[i] = new Worker(MaxPendingResults / Environment.ProcessorCount); } }
public BruteCompressingStream(BinaryWriter internalWriter, int maxBufferSize, ICompressionStrategy compressionStrategy) { if (maxBufferSize <= 0 || maxBufferSize >= 1024 * 1024 * 2) { throw new ArgumentOutOfRangeException(nameof(maxBufferSize)); } this.internalWriter = internalWriter; this.compressionStrategy = compressionStrategy; internalBuffer = new byte[maxBufferSize]; bufferOffset = 0; }
IKeyValueDB CreateKeyValueDB(IFileCollection fileCollection, ICompressionStrategy compressionStrategy = null) { if (fileCollection == null) { return(new InMemoryKeyValueDB()); } if (compressionStrategy == null) { return(new KeyValueDB(fileCollection)); } return(new KeyValueDB(fileCollection, compressionStrategy)); }
public ReadOnlyEventStore(IEventFileStorage file, ITypeSerializersMapping mapping, ICompressionStrategy compressionStrategy) { File = file; Mapping = mapping; CompressionStrategy = compressionStrategy; EndBufferPosition = ulong.MaxValue; MaxBlockSize = Math.Min(File.MaxBlockSize, 0x1000000); // For Length there is only 3 bytes so maximum could be less if (MaxBlockSize < FirstReadAhead) { throw new ArgumentException("file.MaxBlockSize is less than FirstReadAhead"); } }
public BlockCompressor( ICompressingSettings compressingSettings, IOutputWriter outputFileWriter, ILogger logger, IBlocksToCompressSource inputBlocksSource, ICompressionStrategy blockCompressionStrategy) : base(compressingSettings) { _outputFileWriter = outputFileWriter ?? throw new ArgumentNullException(nameof(outputFileWriter)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _inputBlocksSource = inputBlocksSource ?? throw new ArgumentNullException(nameof(inputBlocksSource)); _blockCompressionStrategy = blockCompressionStrategy ?? throw new ArgumentNullException(nameof(blockCompressionStrategy)); }
ICancellationStrategy cancellationStrategy; // Aktuális cancel stratégia/viselkedés public DataProcessor(ICompressionStrategy compressionStrategy, ICancellationStrategy cancellationStrategy) { // Ügyelünk arra, hogy null-t nem fogadunk el, az osztály függőségeit kötelező megadni if (compressionStrategy == null) { throw new ArgumentNullException(nameof(compressionStrategy)); } if (cancellationStrategy == null) { throw new ArgumentNullException(nameof(cancellationStrategy)); } // Eltároljuk a paraméterként kapott stratégiákat this.compressionStrategy = compressionStrategy; this.cancellationStrategy = cancellationStrategy; }
IKeyValueDB CreateKeyValueDB(IFileCollection fileCollection, ICompressionStrategy compressionStrategy = null) { if (fileCollection == null) { if (_memoryMapped) { return(new ArtInMemoryKeyValueDB(new HGlobalAllocator())); } else { return(new InMemoryKeyValueDB()); } } if (compressionStrategy == null) { return(new KeyValueDB(fileCollection)); } return(new KeyValueDB(fileCollection, compressionStrategy)); }
public KeyValueDB(IFileCollection fileCollection, ICompressionStrategy compression, uint fileSplitSize, ICompactorScheduler compactorScheduler) { if (fileCollection == null) { throw new ArgumentNullException(nameof(fileCollection)); } if (compression == null) { throw new ArgumentNullException(nameof(compression)); } if (fileSplitSize < 1024 || fileSplitSize > int.MaxValue) { throw new ArgumentOutOfRangeException(nameof(fileSplitSize), "Allowed range 1024 - 2G"); } _compactorScheduler = compactorScheduler; MaxTrLogFileSize = fileSplitSize; _compression = compression; DurableTransactions = false; _fileCollection = new FileCollectionWithFileInfos(fileCollection); _lastCommited = new BTreeRoot(0); LoadInfoAboutFiles(); _compactFunc = _compactorScheduler?.AddCompactAction(Compact); _compactorScheduler?.AdviceRunning(); }
public void SetCompressionStrategy(ICompressionStrategy strategy) { this._compressionStrategy = strategy; }
// Usually, the Context accepts a strategy through the constructor, but // also provides a setter to change it at runtime. // The Client will set what CompressionStrategy to use by calling this method at runtime public void SetStrategy(ICompressionStrategy Compression) { this._compression = Compression; }
public CompressionContext(ICompressionStrategy Compression) { this._compression = Compression; }
public CompressionContext(ICompressionStrategy compressionStrategy) { this.compressionStrategy = compressionStrategy; }
public KeyValueDB(IFileCollection fileCollection, ICompressionStrategy compression, uint fileSplitSize = int.MaxValue) : this(fileCollection, compression, fileSplitSize, CompactorScheduler.Instance) { }
public AppendingEventStore(IEventFileStorage file, ITypeSerializersMapping mapping, ICompressionStrategy compressionStrategy) : base(file, mapping, compressionStrategy) { }
public override IKeyValueDB NewKeyValueDB(IFileCollection fileCollection, ICompressionStrategy compression, uint fileSplitSize, ICompactorScheduler compactorScheduler) { return(NewKeyValueDB(new KeyValueDBOptions { FileCollection = fileCollection, Compression = compression, FileSplitSize = fileSplitSize, CompactorScheduler = compactorScheduler })); }
IKeyValueDB CreateKeyValueDB(IFileCollection fileCollection, ICompressionStrategy compressionStrategy = null) { if (fileCollection == null) return new InMemoryKeyValueDB(); if (compressionStrategy == null) return new KeyValueDB(fileCollection); return new KeyValueDB(fileCollection, compressionStrategy); }
public EventStoreManager() { CompressionStrategy = new SnappyCompressionStrategy(); }
public override void CompressCoordinates(ICompressionStrategy compressionStrategy) { compressionStrategy.Compress(ref Coordinates[0]); }
public DataCompressor(ICompressionStrategy compressionStrategy) { _compressionStrategy = compressionStrategy; }
public TrlFileReader(IFileCollectionFile file) { _readerController = file.GetExclusiveReader(); _compression = new SnappyCompressionStrategy(); _fileId = file.Index; }
public override IKeyValueDB NewKeyValueDB(IFileCollection fileCollection, ICompressionStrategy compression, uint fileSplitSize = 2147483647) { return(NewKeyValueDB(new KeyValueDBOptions { FileCollection = fileCollection, Compression = compression, FileSplitSize = fileSplitSize })); }
public abstract void CompressCoordinates(ICompressionStrategy compressionStrategy);
public override IKeyValueDB NewKeyValueDB(IFileCollection fileCollection, ICompressionStrategy compression, uint fileSplitSize, ICompactorScheduler compactorScheduler) { return(new KeyValueDB(fileCollection, compression, fileSplitSize, compactorScheduler)); }
public PackageManager(ISerializationStrategy serializationStrategy, ICompressionStrategy compressionStrategy) { _serializationStrategy = serializationStrategy; _compressionStrategy = compressionStrategy; }
public override IKeyValueDB NewKeyValueDB(IFileCollection fileCollection, ICompressionStrategy compression, uint fileSplitSize = 2147483647) { return(new KeyValueDB(fileCollection, compression, fileSplitSize)); }
public EventStoreManager(TypeSerializersOptions?options = null) { _typeSerializers = new TypeSerializers(null, options); CompressionStrategy = new SnappyCompressionStrategy(); }
public TestableGitPackFile( IFileSystem fileSystem, string fileName, ICompressionStrategy compression, Mock<GitPackIndex> index, IDeltaDecoder delta) : base(fileSystem, fileName, compression, index.Object, delta) { MockIndex = index; }