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));
}
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 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;
}
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 AppendingEventStore(IEventFileStorage file, ITypeSerializersMapping mapping, ICompressionStrategy compressionStrategy)
: base(file, mapping, compressionStrategy)
{
}
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;
}
