internal ICompiledQuerySource GetCompiledQuerySourceFor <TDoc, TOut>(ICompiledQuery <TDoc, TOut> query, QuerySession session) { if (_querySources.TryFind(query.GetType(), out var source)) { return(source); } if (typeof(TOut).CanBeCastTo <Task>()) { throw InvalidCompiledQueryException.ForCannotBeAsync(query.GetType()); } var plan = QueryCompiler.BuildPlan(session, query, _store.Options); var file = new CompiledQueryCodeFile(query.GetType(), _store, plan, _tracking); var rules = _store.Options.CreateGenerationRules(); rules.ReferenceTypes(typeof(TDoc), typeof(TOut), query.GetType()); file.InitializeSynchronously(rules, _store, null); source = file.Build(rules); _querySources = _querySources.AddOrUpdate(query.GetType(), source); return(source); }
public void AppendServices(IServiceCollection services) { lock (_familyLock) { var(registry, scanners) = ScanningExploder.ExplodeSynchronously(services); Scanners = Scanners.Union(scanners).ToArray(); registry .Where(x => !x.ServiceType.HasAttribute <LamarIgnoreAttribute>()) .GroupBy(x => x.ServiceType) .Each(group => { if (_families.ContainsKey(group.Key)) { var family = _families[group.Key]; if (family.Append(@group, DecoratorPolicies) == AppendState.NewDefault) { _byType = _byType.Remove(group.Key); } } else { var family = buildFamilyForInstanceGroup(services, @group); _families.Add(@group.Key, family); } }); buildOutMissingResolvers(); rebuildReferencedAssemblyArray(); } }
public DocumentPersistence <T> StorageFor <T>() { if (_storage.TryFind(typeof(T), out var stored)) { return(stored.As <DocumentPersistence <T> >()); } var mapping = _options.Storage.FindMapping(typeof(T)); if (mapping is DocumentMapping m) { var builder = new DocumentPersistenceBuilder(m, _options); var slot = builder.Generate <T>(); _storage = _storage.AddOrUpdate(typeof(T), slot); return(slot); } if (mapping is SubClassMapping s) { var loader = typeof(SubClassLoader <, ,>).CloseAndBuildAs <ISubClassLoader <T> >(mapping.Root.DocumentType, typeof(T), mapping.IdType); var slot = loader.BuildPersistence(this, s); _storage = _storage.AddOrUpdate(typeof(T), slot); return(slot); } throw new NotSupportedException("Unable to build document persistence handlers for " + mapping.DocumentType.FullNameInCode()); }
public void Append <T>(DocumentProvider <T> provider) { // This might cause Marten to re-check the database storage, but double dipping // seems smarter than trying to be too clever and miss doing the check _storage = _storage.Remove(typeof(T)); _inner.Append(provider); }
public void Group() { lock (_groupingLock) { if (_hasGrouped) { return; } _calls.Where(x => TypeExtensions.IsConcrete(x.MessageType)) .GroupBy(x => x.MessageType) .Select(group => new HandlerChain(@group)) .Each(chain => { _chains = _chains.AddOrUpdate(chain.MessageType, chain); }); _calls.Where(x => !TypeExtensions.IsConcrete(x.MessageType)) .Each(call => { Chains .Where(c => call.CouldHandleOtherMessageType(c.MessageType)) .Each(c => { c.AddAbstractedHandler(call); }); }); _hasGrouped = true; } }
private IAggregateFetchPlan <TDoc, TId> determineFetchPlan <TDoc, TId>() where TDoc : class { if (_fetchStrategies.TryFind(typeof(TDoc), out var stored)) { return((IAggregateFetchPlan <TDoc, TId>)stored); } // All the IDocumentStorage types are codegen'd // ReSharper disable once SuspiciousTypeConversion.Global var documentProvider = _store.Options.Providers.StorageFor <TDoc>(); var storage = (IDocumentStorage <TDoc, TId>)documentProvider.IdentityMap; IAggregateFetchPlan <TDoc, TId> plan; if (_store.Options.Projections.DoesPersistAggregate(typeof(TDoc))) { plan = new FetchInlinedPlan <TDoc, TId>(_store.Events, (IEventIdentityStrategy <TId>) this, storage); } else { plan = new FetchLivePlan <TDoc, TId>(_store.Events, (IEventIdentityStrategy <TId>) this, storage); } _fetchStrategies = _fetchStrategies.AddOrUpdate(typeof(TDoc), plan); return(plan); }
/// Creates the branch node with known height public Branch(int hash, K key, V value, ImHashMap <K, V> left, ImHashMap <K, V> right, int height) : base(hash, key, value) { LeftNode = left; RightNode = right; BranchHeight = height; }
public void AppendServices(IServiceCollection services) { lock (_familyLock) { applyScanners(services).Wait(TimeSpan.FromSeconds(2)); services .Where(x => !x.ServiceType.HasAttribute <LamarIgnoreAttribute>()) .GroupBy(x => x.ServiceType) .Each(group => { if (_families.ContainsKey(group.Key)) { var family = _families[group.Key]; if (family.Append(group) == AppendState.NewDefault) { _byType = _byType.Remove(group.Key); } } else { var family = buildFamilyForInstanceGroup(services, @group); _families.Add(@group.Key, family); } }); buildOutMissingResolvers(); rebuildReferencedAssemblyArray(); } }
/// Creates branch with known heights of left and right public Branch(int hash, K key, V value, int leftHeight, ImHashMap <K, V> left, int rightHeight, ImHashMap <K, V> right) : base(hash, key, value) { LeftNode = left; RightNode = right; BranchHeight = leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1; }
/// Creates the branch node with known height internal ConflictsBranch( int hash, K key, V value, KV <K, V>[] conflicts, ImHashMap <K, V> left, ImHashMap <K, V> right, int height) : base(hash, key, value, left, right, height) { Conflicts = conflicts; }
public void Init() { var r = new Random(4); _keys = new List <T>(); _immDict = ImmutableDictionary <T, int> .Empty; _sasaTrie = Trie <T, int> .Empty; _sGuh = ImmutableTrieDictionary.Create <T, int>(); _tvl = ImmutableTreeDictionary <T, int> .Empty; _imToolsHashMap = ImHashMap <T, int> .Empty; _apexHashMap = HashMap <T, int> .Empty; for (int i = 0; i < Count; ++i) { var k = GenerateValue(r); _immDict = _immDict.SetItem(k, i); _sasaTrie = _sasaTrie.Add(k, i); _sGuh = _sGuh.Add(k, i); _tvl = _tvl.Add(k, i); _imToolsHashMap = _imToolsHashMap.AddOrUpdate(k, i); _apexHashMap = _apexHashMap.SetItem(k, i); _keys.Add(k); } int n = _keys.Count; while (n > 1) { n--; int k = r.Next(n + 1); var value = _keys[k]; _keys[k] = _keys[n]; _keys[n] = value; } }
public Cache(IDictionary <TKey, TValue> dictionary) { foreach (var pair in dictionary) { _values = _values.AddOrUpdate(pair.Key, pair.Value); } }
public DocumentProvider <T> StorageFor <T>() where T : notnull { var documentType = typeof(T); if (_storage.TryFind(documentType, out var stored)) { return(stored.As <DocumentProvider <T> >()); } if (documentType == typeof(IEvent)) { var slot = EventDocumentStorageGenerator.BuildProvider(_options); _storage = _storage.AddOrUpdate(documentType, slot); return(slot.As <DocumentProvider <T> >()); } var mapping = _options.Storage.FindMapping(documentType); switch (mapping) { case DocumentMapping m: { var builder = new DocumentPersistenceBuilder(m, _options); var slot = builder.Generate <T>(); _storage = _storage.AddOrUpdate(documentType, slot); return(slot); } case SubClassMapping s: { var loader = typeof(SubClassLoader <, ,>).CloseAndBuildAs <ISubClassLoader <T> >(mapping.Root.DocumentType, documentType, mapping.IdType); var slot = loader.BuildPersistence(this, s); _storage = _storage.AddOrUpdate(documentType, slot); return(slot); } case EventMapping em: { var storage = (IDocumentStorage <T>)em; var slot = new DocumentProvider <T> { Lightweight = storage, IdentityMap = storage, DirtyTracking = storage, QueryOnly = storage }; _storage = _storage.AddOrUpdate(documentType, slot); return(slot); } default: throw new NotSupportedException("Unable to build document persistence handlers for " + mapping.DocumentType.FullNameInCode()); } }
public HandlerGraph() { // All of this is to seed the handler and its associated retry policies // for scheduling outgoing messages _handlers = _handlers.AddOrUpdate(typeof(Envelope), new ScheduledSendEnvelopeHandler()); GlobalPolicy <SagaFramePolicy>(); }
/// Creates branch with known height of right sub-tree public Branch(int hash, K key, V value, ImHashMap <K, V> left, int rightHeight, ImHashMap <K, V> right) : base(hash, key, value) { LeftNode = left; RightNode = right; var leftHeight = left == null ? 0 : left is Branch lb ? lb.BranchHeight : 1; BranchHeight = leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1; }
public void RouteToDestination(Envelope envelope) { if (!_destinations.TryFind(envelope.Destination, out var route)) { route = DetermineDestinationRoute(envelope.Destination); _destinations = _destinations.AddOrUpdate(envelope.Destination, route); } route.Configure(envelope); }
public void Dispose() { foreach (var channel in _subscribers.Enumerate()) { channel.Value.Dispose(); } _subscribers = ImHashMap <Uri, ISubscriber> .Empty; }
private ISendingAgent addQueue(IMessagingRoot root, ITransportRuntime runtime, LocalQueueSettings queue) { queue.Agent = buildAgent(queue, root); _agents = _agents.AddOrUpdate(queue.Name, buildAgent(queue, root)); runtime.AddSendingAgent(buildAgent(queue, root)); runtime.AddSubscriber(queue); return(queue.Agent); }
public void Dispose() { foreach (var channel in _channels.Enumerate()) { channel.Value.Dispose(); } _channels = ImHashMap <Uri, IChannel> .Empty; }
Task IGeneratesCode.AttachGeneratedTypes(GenerationRules rules, IServiceProvider services) { foreach (var chain in Chains) { var handler = chain.CreateHandler((IContainer)services); _handlers = _handlers.Update(chain.MessageType, handler); } return(Task.CompletedTask); }
/// <summary> /// Register a database that will hold data for multiple conjoined tenants /// </summary> /// <param name="connectionString"></param> /// <param name="databaseIdentifier">A descriptive name for this database. If omitted, this will be derived from the connection string</param> /// <returns></returns> public IDatabaseExpression AddMultipleTenantDatabase(string connectionString, string databaseIdentifier = null) { var builder = new NpgsqlConnectionStringBuilder(connectionString); var identifier = databaseIdentifier ?? $"{builder.Database}@{builder.Host}"; var database = new MartenDatabase(Options, new ConnectionFactory(connectionString), identifier); _databases = _databases.AddOrUpdate(identifier, database); return(new DatabaseExpression(this, database)); }
public IntsAddBenchmark() { _numbers = new int[N]; for (int i = 0; i < _numbers.Length; i++) { _numbers[i] = _random.Next(); } _sut = ImmutableDictionary <int, int> .Empty; _sutBCL = ImmutableDictionaryBCL.Empty; _sutIm = ImHashMap <int, int> .Empty; }
public MessageRoute[] Route(Type messageType) { if (_routes.TryFind(messageType, out var routes)) { return(routes); } routes = compileRoutes(messageType).ToArray(); _routes = _routes.AddOrUpdate(messageType, routes); return(routes); }
internal IEnumerable <Type> GetTypeDependencies(Type type) { if (_typeDependencies.TryFind(type, out var deps)) { return(deps); } deps = determineTypeDependencies(type); _typeDependencies = _typeDependencies.AddOrUpdate(type, deps); return(deps); }
public static Task <AssemblyTypes> ForAssembly(Assembly assembly) { if (_assemblies.TryFind(assembly, out var types)) { return(types); } types = Task.Factory.StartNew(() => new AssemblyTypes(assembly)); _assemblies = _assemblies.AddOrUpdate(assembly, types); return(types); }
public async Task <MessageRoute[]> Route(Type messageType) { if (_routes.TryFind(messageType, out var routes)) { return(routes); } routes = (await compileRoutes(messageType)).ToArray(); _routes = _routes.AddOrUpdate(messageType, routes); return(routes); }
public ReaderCollection <TReader> ReaderFor(string messageType) { if (_modelReaders.TryFind(messageType, out var reader)) { return(reader); } var modelReader = compileReader(messageType); _modelReaders = _modelReaders.AddOrUpdate(messageType, modelReader); return(modelReader); }
public WriterCollection <TWriter> WriterFor(Type messageType) { if (_modelWriters.TryFind(messageType, out var writer)) { return(writer); } var modelWriter = compileWriter(messageType); _modelWriters = _modelWriters.AddOrUpdate(messageType, modelWriter); return(modelWriter); }
public void AddSingleTenantDatabase(string connectionString, string tenantId) { var database = new MartenDatabase(Options, new ConnectionFactory(connectionString), tenantId); _databases = _databases.AddOrUpdate(tenantId, database); var expression = new DatabaseExpression(this, database).ForTenants(tenantId); if (Default == null) { expression.AsDefault(); } }
private void buildInitialSendingAgents(IMessagingRoot root) { foreach (var subscriberAddress in root.Settings.KnownSubscribers) { var transport = _transports[subscriberAddress.Uri.Scheme]; var agent = transport.BuildSendingAgent(subscriberAddress.Uri, root, _settings.Cancellation); var channel = new Channel(_logger, subscriberAddress, transport.LocalReplyUri, agent); _channels = _channels.AddOrUpdate(subscriberAddress.Uri, channel); } }