public CommandBus(IEventStore eventstore, HandlerRegistry handlerregistry, IHandlerInstanceResolver resolver, IParameterResolver ParameterResolver)
{
this.eventstore = eventstore;
this.handlerregistry = handlerregistry;
this.resolver = resolver;
this.ParameterResolver = ParameterResolver;
}
public EventApplier(IEventStore eventstore, HandlerRegistry handlerregistry, IHandlerInstanceResolver resolver,IParameterResolver parameterresolver)
{
this.eventstore = eventstore;
this.handlerregistry = handlerregistry;
this.resolver = resolver;
this.parameterresolver = parameterresolver;
}
private static void EmitResolveParameter(ILGenerator il, ParameterInfo param)
{
ParameterAttribute attr = GetParameterAttribute(param);
IParameterResolver resolver = ParameterResolverMap.GetResolver(attr);
resolver.EmitParameterResolution(il, attr, param.ParameterType);
}
public EventApplier(IEventStore eventstore, HandlerRegistry handlerregistry, IHandlerInstanceResolver resolver, IParameterResolver parameterresolver)
{
this.eventstore = eventstore;
this.handlerregistry = handlerregistry;
this.resolver = resolver;
this.parameterresolver = parameterresolver;
}
public DashTween Execute(Transform p_transform, IParameterResolver p_resolver, NodeFlowData p_flowData)
{
// RectTransform rect = p_transform as RectTransform;
//
// Vector2 startPosition = rect.anchoredPosition;
//
// Sequence sequence = DOTween.Sequence();
//
// for (int i = 0; i < shakeCount; i++)
// {
// float f = fade ? ((shakeCount - i) / (float)shakeCount) : 1;
// Tween tween1 = DOTween
// .To(() => rect.anchoredPosition-startPosition, v2 => rect.anchoredPosition = startPosition+v2,
// new Vector2(Random.Range(-shakeStrength*f, shakeStrength*f), Random.Range(-shakeStrength*f, shakeStrength*f)),
// p_duration / (shakeCount * 2))
// .SetEase(Ease.OutQuad);
// sequence.Append(tween1);
//
// Tween tween2 = DOTween
// .To(() => rect.anchoredPosition-startPosition, v2 => rect.anchoredPosition = startPosition+v2,
// Vector2.zero, p_duration / (shakeCount * 2))
// .SetEase(Ease.InQuad);
// sequence.Append(tween2);
// }
//
// return sequence;
// TODO DashTween implementation
return(null);
}
public CommandBus(IEventStore eventstore, HandlerRegistry handlerregistry, IHandlerInstanceResolver resolver,IParameterResolver ParameterResolver)
{
this.eventstore = eventstore;
this.handlerregistry = handlerregistry;
this.resolver = resolver;
this.ParameterResolver = ParameterResolver;
}
public void TestResolvesToMessageIdentifierWhenAnnotatedForCommandMessage()
{
IParameterResolver resolver = _testSubject.CreateInstance(_messageIdentifierMethod, _messageIdentifierMethod.GetParameters(), 0);
var eventMessage = GenericCommandMessage.AsCommandMessage("test");
resolver.Matches(eventMessage).Should().BeTrue();
resolver.ResolveParameterValue(eventMessage).Should().Be(eventMessage.Identifier);
}
public void ShouldBeAbleToAddCustomParameterAttribute()
{
ParameterResolverMap.AddResolver(typeof(MockParamterAttribute), new MockParameterResolver());
IParameterResolver resolver = ParameterResolverMap.GetResolver(new MockParamterAttribute());
Assert.IsNotNull(resolver);
Assert.IsInstanceOfType(resolver, typeof(MockParameterResolver));
}
/// <summary>
/// Adds a <see cref="ParameterResolver"/> used to resolve a specific <see cref="ParameterAttribute"/>.
/// </summary>
/// <param name="attributeType">The type, which should be assignable from <see cref="ParameterAttribute"/>.</param>
/// <param name="parameterResolver">The resolver used to emit the IL code.</param>
public static void AddResolver(Type attributeType, IParameterResolver parameterResolver)
{
Guard.ArgumentNotNull(attributeType, "attributeType");
Guard.ArgumentNotNull(parameterResolver, "parameterResolver");
Guard.TypeIsAssignableFromType(typeof (ParameterAttribute), attributeType, "attributeType");
resolvers[attributeType] = parameterResolver;
}
public override void Initialize(IDependencyResolver resolver)
{
_proxyGenerator = resolver.Resolve <IJavaScriptProxyGenerator>();
_manager = resolver.Resolve <IHubManager>();
_binder = resolver.Resolve <IParameterResolver>();
_requestParser = resolver.Resolve <IHubRequestParser>();
base.Initialize(resolver);
}
/// <summary>
/// Adds a <see cref="ParameterResolver"/> used to resolve a specific <see cref="ParameterAttribute"/>.
/// </summary>
/// <param name="attributeType">The type, which should be assignable from <see cref="ParameterAttribute"/>.</param>
/// <param name="parameterResolver">The resolver used to emit the IL code.</param>
public static void AddResolver(Type attributeType, IParameterResolver parameterResolver)
{
Guard.ArgumentNotNull(attributeType, "attributeType");
Guard.ArgumentNotNull(parameterResolver, "parameterResolver");
Guard.TypeIsAssignableFromType(typeof(ParameterAttribute), attributeType, "attributeType");
resolvers[attributeType] = parameterResolver;
}
static void EvaluateParameter(string p_name, ParameterArgs p_args, IParameterResolver p_resolver, IAttributeDataCollection p_collection, bool p_referenced)
{
//Debug.Log("EvaluateParameter: "+p_name);
p_args.Result = p_resolver.Resolve(p_name, p_collection, p_referenced);
// Only log first error
if (!hasErrorInEvaluation && p_resolver.hasErrorInResolving)
{
errorMessage = p_resolver.errorMessage;
}
hasErrorInEvaluation = hasErrorInEvaluation || p_resolver.hasErrorInResolving;
}
private void EmitResolveProperty(ILGenerator il, PropertyInfo prop)
{
ParameterAttribute attr = GetParameterAttribute(prop);
IParameterResolver resolver = ParameterResolverMap.GetResolver(attr);
resolver.EmitParameterResolution(il, attr, prop.PropertyType);
if (prop.PropertyType.IsValueType)
{
il.Emit(OpCodes.Unbox_Any, prop.PropertyType);
}
}
public void ApplyEventsToInstance(object instance, IParameterResolver pr)
{
var instancetype = instance.GetType();
foreach (var evt in eventsource.GetNewEvents(instance))
{
if (this.handlerregistry.ContainsHandler(instancetype, evt.GetType()))
{
this.handlerregistry[instancetype, evt.GetType()](instance, evt, pr);
}
}
}
public ScritchyBus(Func<Type, object> LoadHandler = null, IEventstoreAdapter adapter = null, bool DoNotApplyEvents = false)
{
if (LoadHandler == null)
LoadHandler = x => Activator.CreateInstance(x);
EventStore = new Scritchy.Infrastructure.Implementations.EventStorage.EventStore(adapter: adapter);
Registry = new ConventionBasedRegistry();
resolver = new HandlerInstanceResolver(EventStore, Registry, LoadHandler);
ParameterResolver = new ParameterResolver(resolver);
Bus = new CommandBus(EventStore, Registry, resolver,ParameterResolver);
applier = new EventApplier(EventStore, Registry, resolver,ParameterResolver);
this.DoNotApplyEvents = DoNotApplyEvents;
}
public IParameterResolver CreateInstance(MethodBase executable, ParameterInfo[] parameters, int parameterIndex)
{
foreach (IParameterResolverFactory factory in _factories)
{
IParameterResolver resolver = factory.CreateInstance(executable, parameters, parameterIndex);
if (resolver != null)
{
return(resolver);
}
}
return(null);
}
public AR LoadARSnapshot(Type t, string Id, IParameterResolver pr)
{
var ar = Activator.CreateInstance(t) as AR;
ar.Id = Id;
ar.TryApplyEvent = x => {
if (handlerregistry.ContainsHandler(t, x.GetType()))
{
handlerregistry[t, x.GetType()](ar, x, pr);
}
};
ApplyEventsToInstance(ar, pr);
return(ar);
}
public ScritchyBus(Func <Type, object> LoadHandler = null, IEventstoreAdapter adapter = null, bool DoNotApplyEvents = false)
{
if (LoadHandler == null)
{
LoadHandler = x => Activator.CreateInstance(x);
}
EventStore = new Scritchy.Infrastructure.Implementations.EventStorage.EventStore(adapter: adapter);
Registry = new ConventionBasedRegistry();
resolver = new HandlerInstanceResolver(EventStore, Registry, LoadHandler);
ParameterResolver = new ParameterResolver(resolver);
Bus = new CommandBus(EventStore, Registry, resolver, ParameterResolver);
applier = new EventApplier(EventStore, Registry, resolver, ParameterResolver);
this.DoNotApplyEvents = DoNotApplyEvents;
}
public override void Initialize(IDependencyResolver resolver, HostContext context)
{
if (resolver == null)
{
throw new ArgumentNullException("resolver");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
_proxyGenerator = resolver.Resolve <IJavaScriptProxyGenerator>();
_manager = resolver.Resolve <IHubManager>();
_binder = resolver.Resolve <IParameterResolver>();
_requestParser = resolver.Resolve <IHubRequestParser>();
_pipelineInvoker = resolver.Resolve <IHubPipelineInvoker>();
_counters = resolver.Resolve <IPerformanceCounterManager>();
// Call base initializer before populating _hubs so the _jsonSerializer is initialized
base.Initialize(resolver, context);
// Populate _hubs
string data = context.Request.QueryStringOrForm("connectionData");
if (!String.IsNullOrEmpty(data))
{
var clientHubInfo = JsonSerializer.Parse <IEnumerable <ClientHubInfo> >(data);
if (clientHubInfo != null)
{
foreach (var hubInfo in clientHubInfo)
{
// Try to find the associated hub type
HubDescriptor hubDescriptor = _manager.EnsureHub(hubInfo.Name,
_counters.ErrorsHubResolutionTotal,
_counters.ErrorsHubResolutionPerSec,
_counters.ErrorsAllTotal,
_counters.ErrorsAllPerSec);
if (_pipelineInvoker.AuthorizeConnect(hubDescriptor, context.Request))
{
// Add this to the list of hub descriptors this connection is interested in
_hubs.Add(hubDescriptor);
}
}
}
}
}
public ParameterStartValuesTask(
IInteractionTaskContext interactionTaskContext,
IEditTasksForBuildingBlock <IParameterStartValuesBuildingBlock> editTask,
IParameterStartValuesCreator startValuesCreator,
ICloneManagerForBuildingBlock cloneManagerForBuildingBlock,
IImportedQuantityToParameterStartValueMapper dtoToQuantityToParameterStartValueMapper,
IParameterResolver parameterResolver,
IParameterStartValueBuildingBlockMergeManager parameterStartValueBuildingBlockMergeManager,
IMoBiFormulaTask moBiFormulaTask,
IMoBiSpatialStructureFactory spatialStructureFactory, IParameterStartValuePathTask parameterStartValuePathTask)
: base(interactionTaskContext, editTask, parameterStartValueBuildingBlockMergeManager, cloneManagerForBuildingBlock, moBiFormulaTask, spatialStructureFactory, dtoToQuantityToParameterStartValueMapper, parameterStartValuePathTask)
{
_startValuesCreator = startValuesCreator;
_parameterResolver = parameterResolver;
}
protected override void Context()
{
_context = A.Fake <IInteractionTaskContext>();
_editTasks = A.Fake <IEditTasksForBuildingBlock <IParameterStartValuesBuildingBlock> >();
_parameterStartValuesCreator = A.Fake <IParameterStartValuesCreator>();
_cloneManagerForBuildingBlock = A.Fake <ICloneManagerForBuildingBlock>();
_parameterStartValueBuildingBlock = new ParameterStartValuesBuildingBlock();
_parameterResolver = A.Fake <IParameterResolver>();
sut = new ParameterStartValuesTask(_context, _editTasks,
_parameterStartValuesCreator,
_cloneManagerForBuildingBlock,
new ImportedQuantityToParameterStartValueMapper(_parameterStartValuesCreator), _parameterResolver, A.Fake <IParameterStartValueBuildingBlockMergeManager>(),
A.Fake <IMoBiFormulaTask>(), A.Fake <IMoBiSpatialStructureFactory>(), new ParameterStartValuePathTask(A.Fake <IFormulaTask>(), _context.Context));
}
public static object EvaluateUntypedExpression(string p_expression, IParameterResolver p_resolver, IAttributeDataCollection p_collection, bool p_referenced)
{
hasErrorInEvaluation = false;
if (_cachedExpressions == null)
{
_cachedExpressions = new Dictionary <string, Expression>();
}
Expression cachedExpression;
if (!_cachedExpressions.ContainsKey(p_expression))
{
cachedExpression = new Expression(p_expression);
_cachedExpressions.Add(p_expression, cachedExpression);
}
else
{
cachedExpression = _cachedExpressions[p_expression];
}
EvaluateFunctionHandler evalFunction = (name, args) => EvaluateFunction(name, args);
cachedExpression.EvaluateFunction += evalFunction;
EvaluateParameterHandler evalParam = (name, args) => EvaluateParameter(name, args, p_resolver, p_collection, p_referenced);
cachedExpression.EvaluateParameter += evalParam;
object obj = null;
try
{
obj = cachedExpression.Evaluate();
}
catch (Exception e)
{
// Only set if we didn't already encounter error in evaluation otherwise this may be unspecified exception as a result of the already logged error so we don't want to overwrite it
if (!hasErrorInEvaluation)
{
errorMessage = e.Message;
hasErrorInEvaluation = true;
}
}
cachedExpression.EvaluateFunction -= evalFunction;
cachedExpression.EvaluateParameter -= evalParam;
return(obj);
}
public AliasService(IDataSourceService databaseService,
IParameterResolver argumentHandler,
ICommandRunner runner,
ILogService log,
IMacroRunner macroService,
IPluginManager pluginManager
)
{
_pluginManager = pluginManager;
_macroRunner = macroService;
_cmdRunner = runner;
_log = log;
_databaseService = databaseService;
_resolver = argumentHandler;
}
public override void Initialize(IDependencyResolver resolver)
{
_proxyGenerator = resolver.Resolve <IJavaScriptProxyGenerator>();
_manager = resolver.Resolve <IHubManager>();
_binder = resolver.Resolve <IParameterResolver>();
_requestParser = resolver.Resolve <IHubRequestParser>();
var counters = resolver.Resolve <IPerformanceCounterWriter>();
_allErrorsTotalCounter = counters.GetCounter(PerformanceCounters.ErrorsAllTotal);
_allErrorsPerSecCounter = counters.GetCounter(PerformanceCounters.ErrorsAllPerSec);
_hubInvocationErrorsTotalCounter = counters.GetCounter(PerformanceCounters.ErrorsHubInvocationTotal);
_hubInvocationErrorsPerSecCounter = counters.GetCounter(PerformanceCounters.ErrorsHubInvocationPerSec);
_hubResolutionErrorsTotalCounter = counters.GetCounter(PerformanceCounters.ErrorsHubResolutionTotal);
_hubResolutionErrorsPerSecCounter = counters.GetCounter(PerformanceCounters.ErrorsHubResolutionPerSec);
base.Initialize(resolver);
}
public override void Initialize(IDependencyResolver resolver)
{
if (resolver == null)
{
throw new ArgumentNullException("resolver");
}
_proxyGenerator = _enableJavaScriptProxies ? resolver.Resolve <IJavaScriptProxyGenerator>()
: new EmptyJavaScriptProxyGenerator();
_manager = resolver.Resolve <IHubManager>();
_binder = resolver.Resolve <IParameterResolver>();
_requestParser = resolver.Resolve <IHubRequestParser>();
_serializer = resolver.Resolve <JsonSerializer>();
_pipelineInvoker = resolver.Resolve <IHubPipelineInvoker>();
_counters = resolver.Resolve <IPerformanceCounterManager>();
base.Initialize(resolver);
}
public override void Initialize(IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
_proxyGenerator = _enableJavaScriptProxies ? serviceProvider.GetRequiredService <IJavaScriptProxyGenerator>()
: new EmptyJavaScriptProxyGenerator();
_manager = serviceProvider.GetRequiredService <IHubManager>();
_binder = serviceProvider.GetRequiredService <IParameterResolver>();
_requestParser = serviceProvider.GetRequiredService <IHubRequestParser>();
_serializer = serviceProvider.GetRequiredService <JsonSerializer>();
_pipelineInvoker = serviceProvider.GetRequiredService <IHubPipelineInvoker>();
_counters = serviceProvider.GetRequiredService <IPerformanceCounterManager>();
base.Initialize(serviceProvider);
}
public MainViewModel(
IAliasService aliasService,
ISettingsService settings,
IEventAggregator ea,
IScreenRuler screenRuler,
ILogService logService,
IParameterResolver resolver,
IUserNotifyer notifyer
)
{
Notifyer = notifyer;
LogService = logService;
ea.Subscribe(this);
_resolver = resolver;
_screenRuler = screenRuler;
_settingsService = settings;
_aliasService = aliasService;
}
public RequestParameter(string name, IParameterResolver valueResolver)
{
Name = name;
ValueResolver = valueResolver;
}
public DefaultMethodInvoker(IDependencyResolver resolver)
{
_subscriberInfoResolver = resolver.Resolve<ISubscriberInfoResolver>();
_parameterResolver = resolver.Resolve<IParameterResolver>();
}
public RequestParameter(string name, IParameterResolver valueResolver)
{
Name = name;
ValueResolver = valueResolver;
}
public TimestampParameterResolverFactory()
{
_resolver = new TimestampParameterResolver();
}
public void TestIgnoredWhenWrongType()
{
IParameterResolver resolver = _testSubject.CreateInstance(_integerMethod, _integerMethod.GetParameters(), 0);
resolver.Should().BeNull();
}
/// <summary>
/// Initializes a new instance of the <see cref="MatchParameterResolver"/> class.
/// </summary>
/// <param name="next">The next value resolver in the chain.</param>
/// <param name="parameters">The parameters.</param>
public MatchParameterResolver(IParameterResolver next, IEnumerable <IParameter> parameters) : base(next)
{
_parameters = parameters;
}
public static object EvaluateTypedExpression(string p_expression, Type p_returnType, IParameterResolver p_resolver, IAttributeDataCollection p_collection = null)
{
MethodInfo method = typeof(ExpressionEvaluator).GetMethod("EvaluateExpression", BindingFlags.Public | BindingFlags.Static);
MethodInfo generic = method.MakeGenericMethod(p_returnType);
return(generic.Invoke(null, new object[] { p_expression, p_resolver, p_collection, false }));
}
public static T EvaluateExpression <T>(string p_expression, IParameterResolver p_resolver, IAttributeDataCollection p_collection, bool p_referenced)
{
hasErrorInEvaluation = false;
if (_cachedExpressions == null)
{
_cachedExpressions = new Dictionary <string, Expression>();
}
Expression cachedExpression;
if (!_cachedExpressions.ContainsKey(p_expression))
{
// We cache before macro replacement so runtime macro changes are not possible for performance reasons
cachedExpression = new Expression(ReplaceMacros(p_expression));
_cachedExpressions.Add(p_expression, cachedExpression);
}
else
{
cachedExpression = _cachedExpressions[p_expression];
}
EvaluateFunctionHandler evalFunction = (name, args) => EvaluateFunction <T>(name, args);
cachedExpression.EvaluateFunction += evalFunction;
EvaluateParameterHandler evalParam = (name, args) => EvaluateParameter(name, args, p_resolver, p_collection, p_referenced);
cachedExpression.EvaluateParameter += evalParam;
object obj = null;
//try
{
obj = cachedExpression.Evaluate();
}
// catch (Exception e)
// {
// // Only set if we didn't already encounter error in evaluation otherwise this may be unspecified exception as a result of the already logged error so we don't want to overwrite it
// if (!hasErrorInEvaluation)
// {
// errorMessage = e.Message;
// hasErrorInEvaluation = true;-+
// }
// }
cachedExpression.EvaluateFunction -= evalFunction;
cachedExpression.EvaluateParameter -= evalParam;
if (obj != null)
{
Type returnType = obj.GetType();
if (typeof(T).IsAssignableFrom(returnType))
{
return((T)obj);
}
// Explicit numeric type casting at cost of precision/overflow
if (typeof(T).IsNumericType() && returnType.IsNumericType())
{
return((T)Convert.ChangeType(obj, typeof(T)));
}
if (typeof(T).IsImplicitlyAssignableFrom(returnType))
{
return((T)Convert.ChangeType(obj, typeof(T)));
}
if (typeof(T) == typeof(string))
{
return((T)(object)obj.ToString());
}
Debug.LogWarning("Invalid expression casting " + obj.GetType() + " and " + typeof(T));
}
return(default(T));
}
public ViewModelParameterSetter(IParameterResolver parameterResolver, IParameterCache parameterCache)
{
_parameterResolver = parameterResolver ?? throw new ArgumentNullException(nameof(parameterResolver));
_parameterCache = parameterCache ?? throw new ArgumentNullException(nameof(parameterCache));
}
