protected StateBoundComputed(
ComputedOptions options,
State <T> input,
Result <T> output, LTag version, bool isConsistent)
: base(options, input, output, version, isConsistent)
{
}
// Two primary constructors
public ReplicaClientComputed(ComputedOptions options, IReplicaComputed <T> source, InterceptedInput input)
: this(options, source.Replica, input, source.Version)
{
((IComputedImpl)this).AddUsed((IComputedImpl)source);
TrySetOutput(source.Output);
if (!source.IsConsistent)
{
Invalidate();
}
}
// Two primary constructors
public ReplicaMethodComputed(ComputedOptions options, ComputeMethodInput input, IReplicaComputed <T> source)
: this(source.Replica, options, input, source.Version)
{
((IComputedImpl)this).AddUsed((IComputedImpl)source);
// ReSharper disable once VirtualMemberCallInConstructor
TrySetOutput(source.Output);
if (!source.IsConsistent())
{
Invalidate();
}
}
public virtual ComputedOptions?GetComputedOptions(InterceptorBase interceptor, MethodInfo methodInfo)
{
var attribute = GetInterceptedMethodAttribute(methodInfo);
if (attribute == null)
{
return(null);
}
var swapAttribute = GetSwapAttribute(methodInfo);
return(ComputedOptions.FromAttribute(attribute, swapAttribute));
}
public virtual ComputedOptions?GetComputedOptions(MethodInfo methodInfo)
{
var attribute = GetComputeMethodAttribute(methodInfo);
if (attribute == null)
{
return(null);
}
var swapAttribute = GetSwapAttribute(methodInfo);
return(ComputedOptions.FromAttribute(attribute, swapAttribute));
}
public static ComputedOptions?FromAttribute(ComputeMethodAttribute?attribute, SwapAttribute?swapAttribute)
{
if (attribute == null || !attribute.IsEnabled)
{
return(null);
}
var swappingOptions = SwappingOptions.FromAttribute(swapAttribute);
var options = new ComputedOptions(
ToTimeSpan(attribute.KeepAliveTime) ?? Default.KeepAliveTime,
ToTimeSpan(attribute.ErrorAutoInvalidateTime) ?? Default.ErrorAutoInvalidateTime,
ToTimeSpan(attribute.AutoInvalidateTime) ?? Default.AutoInvalidateTime,
swappingOptions,
attribute.RewriteErrors,
attribute.ComputeMethodDefType);
return(options.IsDefault() ? Default : options);
}
protected Computed(ComputedOptions options, ComputeMethodInput input, Result <T> output, LTag version, bool isConsistent = true)
: base(options, input, output, version, isConsistent)
{
}
public Computed(ComputedOptions options, ComputeMethodInput input, LTag version)
: base(options, input, version)
{
}
public ReplicaComputed(ComputedOptions options, ReplicaInput input, Result <T> output, LTag version, bool isConsistent)
: base(options, input, output, version, isConsistent)
{
}
public ReplicaServiceComputed(ComputedOptions options, InterceptedInput input, Exception error, LTag lTag)
: this(options, null, input, new Result <T>(default !, error), lTag, false)
public SwappingComputed(ComputedOptions options, InterceptedInput input, LTag version)
: base(options, input, version)
{
}
public ReplicaClientComputed(ComputedOptions options, InterceptedInput input, Exception error, LTag version)
: this(options, null, input, new Result <T>(default !, error), version, false)
private static TimeSpan?ToTimeSpan(double value) => ComputedOptions.ToTimeSpan(value);
protected ComputeFunctionBase(ComputeMethodDef method, IServiceProvider services)
: base(services)
{
Method = method;
Options = method.Options;
}
public ReplicaMethodComputed(ComputedOptions options, ComputeMethodInput input, Exception error, LTag version)
: this(null, options, input, new Result <T>(default !, error), version, false)
public ReplicaComputed(ComputedOptions options, ReplicaInput input, LTag lTag)
: base(options, input, lTag)
{
}
public ReplicaComputed(ComputedOptions options, ReplicaInput input, Result <T> output, LTag lTag, bool isConsistent = true)
: base(options, input, output, lTag, isConsistent)
{
}
protected SwappingComputed(ComputedOptions options, InterceptedInput input, ResultBox <T> maybeOutput, LTag version, bool isConsistent)
: base(options, input, default, version, isConsistent)
=> _maybeOutput = maybeOutput;
protected ReplicaComputed(ComputedOptions options, ReplicaInput input, LTag version)
: base(options, input, version)
{
}
public StateBoundComputed(
ComputedOptions options,
State <T> input, LTag version)
: base(options, input, version)
{
}
protected InterceptedFunctionBase(InterceptedMethodDescriptor method, IServiceProvider serviceProvider)
: base(serviceProvider)
{
Method = method;
Options = method.Options;
}
