/// <summary> /// Creates a new storage instance with specified types of keys and values. /// </summary> /// <typeparam name="TKey">The type of key</typeparam> /// <typeparam name="TValue">The type of value</typeparam> /// <param name="serializeKey">Key serialization method</param> /// <param name="deserializeKey">Key deserialization method</param> /// <param name="serializeValue">Value serialization method</param> /// <param name="deserializeValue">Value deserialization method</param> /// <param name="settings">Setiings of creating storage</param> /// <returns>New storage instance</returns> public IKeyValueStorage <KeyOf <TKey>, ValueOf <TValue> > CreateRadixTreeStorage <TKey, TValue>( Func <TKey, byte[]> serializeKey, Func <byte[], TKey> deserializeKey, Func <TValue, byte[]> serializeValue, Func <byte[], TValue> deserializeValue, RadixTreeStorageSettings settings) { if (serializeKey == null) { throw new ArgumentNullException(nameof(serializeKey)); } if (deserializeKey == null) { throw new ArgumentNullException(nameof(deserializeKey)); } if (serializeValue == null) { throw new ArgumentNullException(nameof(serializeValue)); } if (deserializeValue == null) { throw new ArgumentNullException(nameof(deserializeValue)); } return(CreateRadixTreeStorage(new Serializer <TKey>(serializeKey, deserializeKey), new Serializer <TValue>(serializeValue, deserializeValue), settings)); }
/// <summary> /// Creates a new bytearray storage instance with specified type of keys. /// </summary> /// <typeparam name="TKey">The type of key</typeparam> /// <param name="serializeKey">Key serialization method</param> /// <param name="deserializeKey">Key deserialization method</param> /// <param name="settings">Setiings of creating storage</param> /// <returns>New storage instance</returns> public IKeyValueStorage <KeyOf <TKey>, ValueOf <byte[]> > CreateRadixTreeByteArrayStorage <TKey>( Func <TKey, byte[]> serializeKey, Func <byte[], TKey> deserializeKey, RadixTreeStorageSettings settings) { return(CreateRadixTreeStorage(serializeKey, deserializeKey, p => p, p => p, settings)); }
/// <summary> /// Creates a new storage instance with specified types of keys using built-in serialization routines. /// Supported types of keys are: int, long, uint, ulong, double, float, DateTime, Guid, string and byte[] /// </summary> /// <typeparam name="TKey">The type of key</typeparam> /// <typeparam name="TValue">The type of value</typeparam> /// <param name="serializeValue">Value serialization method</param> /// <param name="deserializeValue">Value deserialization method</param> /// <param name="settings">Setiings of creating storage</param> /// <returns>New storage instance</returns> public IKeyValueStorage <KeyOf <TKey>, ValueOf <TValue> > CreateRadixTreeStorage <TKey, TValue>( Func <TValue, byte[]> serializeValue, Func <byte[], TValue> deserializeValue, RadixTreeStorageSettings settings) { var keys = BuiltInKeySerializers(); var type = typeof(TKey); if (!keys.ContainsKey(type)) { ThrowNotSupportedType(type, nameof(CreateRadixTreeStorage)); } return(CreateRadixTreeStorage((ISerializer <TKey>)keys[type], new Serializer <TValue>(serializeValue, deserializeValue), settings)); }
private IRadixTreeKeyValueStorage <KeyOf <String>, ValueOf <String> > GetStorage() { var factory = new StorageFactory(); var settings = RadixTreeStorageSettings.Default(); settings.CacheSettings.MaxCachedPages = 3000; settings.CacheSettings.MaxDirtyPages = 2000; settings.ForcedWrites = false; settings.PageSize = PageSize._4096; return((IRadixTreeKeyValueStorage <KeyOf <String>, ValueOf <String> >)factory.CreateRadixTreeStorage( p => Encoding.UTF8.GetBytes(p), p => Encoding.UTF8.GetString(p), p => Encoding.UTF8.GetBytes(p), p => Encoding.UTF8.GetString(p), settings)); }
private static IKeyValueStorage <KeyOf <string>, ValueOf <byte[]> > GetByteArrayStorage() { var factory = new StorageFactory(); return(factory.CreateRadixTreeByteArrayStorage <string>(RadixTreeStorageSettings.Default())); }
/// <summary> /// Creates a new storage instance with specified types of keys and values. /// </summary> /// <typeparam name="TKey">The type of key</typeparam> /// <typeparam name="TValue">The type of value</typeparam> /// <param name="keySerializer">Object implementing ISerializer interface for key serialization</param> /// <param name="valueSerializer">Object implementing ISerializer interface for value serialization</param> /// <param name="settings">Setiings of creating storage</param> /// <returns>New storage instance</returns> public IKeyValueStorage <KeyOf <TKey>, ValueOf <TValue> > CreateRadixTreeStorage <TKey, TValue>(ISerializer <TKey> keySerializer, ISerializer <TValue> valueSerializer, RadixTreeStorageSettings settings) { bool usePageCache = settings.CacheSettings != null; if (settings.MaxEmptyPages < 0) { throw new ArgumentException("MaxEmptyPages shouldn't be negative", nameof(settings)); } if (usePageCache) { if (settings.CacheSettings.MaxCachedPages < 0) { throw new ArgumentException("MaxCachedPages shouldn't be negative", nameof(settings)); } if (settings.CacheSettings.MaxDirtyPages < 0) { throw new ArgumentException("MaxDirtyPages shouldn't be negative", nameof(settings)); } if (settings.CacheSettings.MaxDirtyPages > settings.CacheSettings.MaxCachedPages) { throw new ArgumentException("MaxDirtyPages shouldn be equal to or less than MaxCachedPages", nameof(settings)); } } IPageManager pageManager = null; IPageManager fsPageManager = null; try { fsPageManager = new FileSystemPageManager((int)settings.PageSize, settings.ForcedWrites, 1, true) { MaxEmptyPages = settings.MaxEmptyPages }; pageManager = usePageCache ? new CachingPageManager(fsPageManager, settings.CacheSettings.MaxCachedPages, settings.CacheSettings.MaxDirtyPages) : fsPageManager; var ks = new Serializer <KeyOf <TKey> >(obj => keySerializer.Serialize(obj), bytes => keySerializer.Deserialize(bytes)); var vs = new Serializer <ValueOf <TValue> >(obj => valueSerializer.Serialize(obj), bytes => valueSerializer.Deserialize(bytes)); var radixTree = new RadixTree <KeyOf <TKey>, ValueOf <TValue> >( new RadixTreeNodeStorage(pageManager), new ValueStorage <ValueOf <TValue> >(new MemoryManager(new FreeSpaceMap(pageManager), pageManager), vs), ks); return(new RadixTreeKeyValueStorage <KeyOf <TKey>, ValueOf <TValue> >(pageManager, radixTree, settings.AutoFlushInterval, settings.AutoFlushTimeout)); } catch (Exception) { if (pageManager != null) { pageManager.Close(); } else { fsPageManager?.Close(); } throw; } }
/// <summary> /// Creates a new bytearray storage instance with specified type of keys using built-in serialization routines. /// Supported types of keys are: int, long, uint, ulong, double, float, DateTime, Guid, string and byte[] /// </summary> /// <typeparam name="TKey">The type of key</typeparam> /// <param name="settings">Setiings of creating storage</param> /// <returns>New storage instance</returns> public IKeyValueStorage <KeyOf <TKey>, ValueOf <byte[]> > CreateRadixTreeByteArrayStorage <TKey>( RadixTreeStorageSettings settings) { return(CreateRadixTreeStorage <TKey, byte[]>(p => p, p => p, settings)); }
/// <summary> /// Creates a new storage instance with specified types of keys using built-in serialization routines. /// Supported types of keys are: int, long, uint, ulong, double, float, DateTime, Guid, string and byte[] /// </summary> /// <typeparam name="TKey">The type of key</typeparam> /// <typeparam name="TValue">The type of value</typeparam> /// <param name="valueSerializer">Object implementing ISerializer interface for value serialization</param> /// <param name="settings">Setiings of creating storage</param> /// <returns>New storage instance</returns> public IKeyValueStorage <KeyOf <TKey>, ValueOf <TValue> > CreateRadixTreeStorage <TKey, TValue>(ISerializer <TValue> valueSerializer, RadixTreeStorageSettings settings) { var keys = BuiltInKeySerializers(); var type = typeof(TKey); if (!keys.ContainsKey(type)) { ThrowNotSupportedType(type, nameof(CreateRadixTreeStorage)); } return(CreateRadixTreeStorage((ISerializer <TKey>)keys[type], valueSerializer, settings)); }