public IChannel GetOrBuildChannel(Uri address)
{
var uri = _lookups == null ? address : _lookups.Resolve(address);
assertValidTransport(uri);
if (_channels.TryFind(uri, out var channel))
{
return(channel);
}
lock (_channelLock)
{
if (!_channels.TryFind(uri, out channel))
{
channel = buildChannel(address);
_channels = _channels.AddOrUpdate(address, channel);
}
return(channel);
}
}
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);
}
/// <summary>
/// These mappings should only be used for Linq querying within the SelectMany() body
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
internal IFieldMapping ChildTypeMappingFor(Type type)
{
if (_childFieldMappings.TryFind(type, out var mapping))
{
return(mapping);
}
mapping = new FieldMapping("d.data", type, this);
_childFieldMappings = _childFieldMappings.AddOrUpdate(type, mapping);
return(mapping);
}
public ModelReader ReaderFor(string messageType)
{
if (_modelReaders.TryFind(messageType, out var reader))
{
return(reader);
}
var modelReader = compileReader(messageType);
_modelReaders = _modelReaders.AddOrUpdate(messageType, modelReader);
return(modelReader);
}
public DocumentProvider <T> StorageFor <T>()
{
if (_storage.TryFind(typeof(T), out var stored))
{
return(stored.As <DocumentProvider <T> >());
}
Tenant.EnsureStorageExists(typeof(T));
var persistence = _inner.StorageFor <T>();
_storage = _storage.AddOrUpdate(typeof(T), persistence);
return(persistence);
}
public ValueTask <IMartenDatabase> FindOrCreateDatabase(string tenantIdOrDatabaseIdentifier)
{
if (_databases.TryFind(tenantIdOrDatabaseIdentifier, out var database))
{
return(new ValueTask <IMartenDatabase>(database));
}
if (_tenants.TryFind(tenantIdOrDatabaseIdentifier, out var tenant))
{
return(new ValueTask <IMartenDatabase>(tenant.Database));
}
throw new UnknownTenantIdException(tenantIdOrDatabaseIdentifier);
}
internal ICompiledQuerySource GetCompiledQuerySourceFor <TDoc, TOut>(ICompiledQuery <TDoc, TOut> query, IMartenSession session)
{
if (_querySources.TryFind(query.GetType(), out var source))
{
return(source);
}
var plan = QueryCompiler.BuildPlan(session, query, this);
source = new CompiledQuerySourceBuilder(plan, this).Build();
_querySources = _querySources.AddOrUpdate(query.GetType(), source);
return(source);
}
public static string DetermineTopicName(Type messageType)
{
if (_topics.TryFind(messageType, out var topic))
{
return(topic);
}
topic = messageType.HasAttribute <TopicAttribute>()
? messageType.GetAttribute <TopicAttribute>().TopicName
: messageType.ToMessageTypeName();
_topics = _topics.AddOrUpdate(messageType, topic);
return(topic);
}
internal ILiveAggregator <T> AggregatorFor <T>() where T : class
{
if (_liveAggregators.TryFind(typeof(T), out var aggregator))
{
return((ILiveAggregator <T>)aggregator);
}
var source = tryFindProjectionSourceForAggregateType <T>();
source.AssertValidity();
aggregator = source.As <ILiveAggregatorSource <T> >().Build(_options);
_liveAggregators = _liveAggregators.AddOrUpdate(typeof(T), aggregator);
return((ILiveAggregator <T>)aggregator);
}
private string locatorForField(string key)
{
if (_indexLocators.TryFind(key, out var locator))
{
return(locator);
}
locator = $"{RawLocator.Replace("->>", "->")} ->> '{key}'";
if (!_valueIsObject)
{
locator = $"CAST({locator} as {_valuePgType})";
}
_indexLocators = _indexLocators.AddOrUpdate(key, locator);
return(locator);
}
internal ILiveAggregator <T> AggregatorFor <T>() where T : class
{
if (_liveAggregators.TryFind(typeof(T), out var aggregator))
{
return((ILiveAggregator <T>)aggregator);
}
if (!_liveAggregateSources.TryGetValue(typeof(T), out var source))
{
source = new AggregateProjection <T>();
source.As <IValidatedProjection>().AssertValidity();
}
aggregator = source.As <ILiveAggregatorSource <T> >().Build(_options);
_liveAggregators = _liveAggregators.AddOrUpdate(typeof(T), aggregator);
return((ILiveAggregator <T>)aggregator);
}
public MessageHandler HandlerFor(Type messageType)
{
if (_handlers.TryFind(messageType, out var handler))
{
return(handler);
}
if (_chains.TryFind(messageType, out var chain))
{
if (chain.Handler != null)
{
handler = chain.Handler;
}
else
{
lock (chain)
{
if (chain.Handler == null)
{
var generatedAssembly = new GeneratedAssembly(_generation);
chain.AssembleType(_generation, generatedAssembly, Container);
new AssemblyGenerator().Compile(generatedAssembly, Container.CreateServiceVariableSource());
handler = chain.CreateHandler(Container);
}
else
{
handler = chain.Handler;
}
}
}
_handlers = _handlers.AddOrUpdate(messageType, handler);
return(handler);
}
// memoize the "miss"
_handlers = _handlers.AddOrUpdate(messageType, null);
return(null);
}
internal ICompiledQuerySource GetCompiledQuerySourceFor <TDoc, TOut>(ICompiledQuery <TDoc, TOut> query, IMartenSession 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, this);
source = new CompiledQuerySourceBuilder(plan, this).Build();
_querySources = _querySources.AddOrUpdate(query.GetType(), source);
return(source);
}
public string ImHashMap_TryFind()
{
_map.TryFind(LookupKey, out var result);
return(result);
}
public Func <IMessageContext, Task <IContinuation> > ExecutorFor(Type messageType)
{
if (_executors.TryFind(messageType, out var executor))
{
return(executor);
}
var handler = _graph.HandlerFor(messageType);
// Memoize the null
if (handler == null)
{
_executors = _executors.AddOrUpdate(messageType, null);
return(null);
}
var policy = handler.Chain.Retries.BuildPolicy(_graph.Retries);
if (policy == null)
{
executor = async messageContext =>
{
messageContext.Envelope.Attempts++;
try
{
try
{
await handler.Handle(messageContext);
}
catch (Exception e)
{
messageContext.MarkFailure(e);
return(new MoveToErrorQueue(e));
}
messageContext.Envelope.MarkCompletion(true);
return(MessageSucceededContinuation.Instance);
}
catch (Exception e)
{
messageContext.MarkFailure(e);
return(new MoveToErrorQueue(e));
}
};
}
else
{
executor = async messageContext =>
{
messageContext.Envelope.Attempts++;
messageContext.Envelope.StartTiming();
try
{
var pollyContext = new Context();
pollyContext.Store(messageContext);
return(await policy.ExecuteAsync(async c =>
{
var context = c.MessageContext();
try
{
await handler.Handle(context);
}
catch (Exception e)
{
messageContext.MarkFailure(e);
throw;
}
messageContext.Envelope.MarkCompletion(true);
return MessageSucceededContinuation.Instance;
}, pollyContext));
}
catch (Exception e)
{
messageContext.MarkFailure(e);
return(new MoveToErrorQueue(e));
}
};
}
_executors = _executors.AddOrUpdate(messageType, executor);
return(executor);
}
public void TestHashImp()
{
_imHashMap.TryFind("11", out var result);
_imHashMap.TryFind("2", out result);
}
public bool GetFromImHashMap() => _imMap.TryFind(_key, out var _);