public static string Filter(this string value, FilterAction matchRule, UnicodeCategory categories)
{
return new string((from c in value
where matchRule == FilterAction.Keep
? categories.HasFlag(Char.GetUnicodeCategory(c))
: !categories.HasFlag(Char.GetUnicodeCategory(c))
select c).ToArray());
}
public static string Filter(this string value, FilterAction matchRule, params char[] characters)
{
return new string((from c in value
where matchRule == FilterAction.Keep
? characters.Contains(c)
: !characters.Contains(c)
select c).ToArray());
}
public StringFilter(FilterAction action, FeedField scope, IEnumerable<string> patterns)
: base(action, scope)
{
if (patterns == null)
throw new ArgumentNullException("patterns");
this.patterns = patterns.ToArray();
}
public RegexFilter(FilterAction action, FeedField scope, IEnumerable<string> patterns)
: base(action, scope)
{
if (patterns == null)
throw new ArgumentNullException("patterns");
this.regularExpressions = patterns
.Select(pattern => new Regex(pattern, RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.Multiline | RegexOptions.IgnoreCase))
.ToArray();
}
public void TypeTest()
{
FilterAction target = new FilterAction();
string val = null; // TODO: Assign to an appropriate value for the property
target.Type = val;
Assert.AreEqual(val, target.Type, "Composestar.StarLight.Entities.WeaveSpec.Instructions.FilterAction.Type was not s" +
"et correctly.");
Assert.Inconclusive("Verify the correctness of this test method.");
}
/// <summary>
/// 点击确认时回调此方法
/// </summary>
/// <returns></returns>
private void OnClickConfirm()
{
if (IsShow)
{
IsShow = false;
if (Table != null && (FilterAction?.GetFilterConditions().Any() ?? false))
{
Table.Filters[FieldKey] = FilterAction;
Table.OnFilterAsync?.Invoke();
}
}
}
public async Task <IResponse> Execute(IRequestContext requestContext, FilterAction next)
{
var cfg = this.routingConfiguration;
if (cfg.Mappings == null || cfg.Mappings.Count == 0)
{
return(null);
}
foreach (var cfgMapping in cfg.Mappings)
{
if (requestContext.Request.UrlPath.StartsWithSegments(cfgMapping.Value.Path, out var remaining))
{
requestContext.Request.UrlHost = cfgMapping.Value.GetRandomHost();
switch (cfgMapping.Value.Strategy)
{
case MappingStrategy.None:
break;
case MappingStrategy.StripPath:
requestContext.Request.UrlPath = remaining;
break;
case MappingStrategy.Replace:
requestContext.Request.UrlPath = cfgMapping.Value.PathReplace + remaining;
break;
}
requestContext.HttpClient = this.httpClientFactory.Create(cfgMapping.Value.HttpClient);
requestContext.Request.Protocol = cfgMapping.Value.Protocol.ToString().ToLower();
var host = ClearHeaders(requestContext.Request.Headers, new[] { requestContext.Request.UrlHost.Value });
if (cfgMapping.Value.ProcessingAction == null)
{
cfgMapping.Value.ProcessingAction = this.filterActionFactory.CreateFilterAction(next, cfgMapping.Value.Filters);
}
IResponse response = await cfgMapping.Value.ProcessingAction(requestContext);
ClearHeaders(response?.Headers, host);
return(response);
}
}
// routing Not Foud
return(null);
}
public BulkProcessing(
bool matchRawMessages,
bool reverseMatchDirection,
IEnumerable <IFilter> filters,
FilterAction defaultAction
)
{
this.filters = filters
.Where(f => f.Enabled)
.Select(f => new KeyValuePair <IFilterBulkProcessing, IFilter>(
f.StartBulkProcessing(matchRawMessages, reverseMatchDirection), f
))
.ToArray();
this.defaultAction = defaultAction;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
internal async Task OnFilterAsync()
{
if (Table != null)
{
if (FilterAction.GetFilterConditions().Any())
{
Table.Filters[FieldKey] = FilterAction;
}
else
{
Table.Filters.Remove(FieldKey);
}
await Table.OnFilterAsync();
}
}
/// <summary>
/// 点击重置按钮时回调此方法
/// </summary>
/// <returns></returns>
private async Task OnClickReset()
{
if (IsShow)
{
IsShow = false;
Count = 0;
if (Table != null)
{
Table.Filters.Remove(FieldKey);
FilterAction.Reset();
await Table.OnFilterAsync();
}
}
}
public BulkProcessing(
MessageTextGetter messageTextGetter,
bool reverseMatchDirection,
IEnumerable <IFilter> filters,
FilterAction defaultAction,
bool timeboxedMatching
)
{
this.filters = filters
.Where(f => f.Enabled)
.Select(f => new KeyValuePair <IFilterBulkProcessing, IFilter>(
f.StartBulkProcessing(messageTextGetter, reverseMatchDirection, timeboxedMatching), f
))
.ToArray();
this.defaultAction = defaultAction;
}
/// <summary>
/// 点击确认时回调此方法
/// </summary>
/// <returns></returns>
private async Task OnClickConfirm()
{
if (IsShow)
{
IsShow = false;
if (Table != null && (FilterAction?.GetFilterConditions().Any() ?? false))
{
Table.Filters[FieldKey] = FilterAction;
if (Table.OnFilterAsync != null)
{
await Table.OnFilterAsync();
}
}
}
}
public void EachGroupDo(FilterAction criteria, Action <G> _action)
{
List <G> groupset = new List <G>();
foreach (G group_key in _Group.Keys)
{
if (criteria(group_key))
{
groupset.Add(group_key);
}
}
foreach (G group in groupset)
{
_action(group);
}
}
/// <summary>
/// Convert from a string value back to a comparison operator.
/// </summary>
/// <param name="value">The value that is produced by the binding target.</param>
/// <param name="targetType">The type to convert to.</param>
/// <param name="parameter">The converter parameter to use.</param>
/// <param name="culture">The culture to use in the converter.</param>
/// <returns>
/// A converted value. If the method returns null, the valid null value is used.
/// </returns>
public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
string name = (string)value;
FilterAction convertedValue = FilterAction.Include;
if (name == "/Resources/OK.png")
{
convertedValue = FilterAction.Include;
}
else if (name == "/Resources/Critical.png")
{
convertedValue = FilterAction.Exclude;
}
return(convertedValue);
}
public void WeavingErrorActionAddsExceptionFilter()
{
string outputFileName = "WeavingErrorActionAddsExceptionFilter.exe";
// set up model
LanguageModelAccessorMock model = new LanguageModelAccessorMock();
// Create inputfilters
Block block = new Block();
Block block2 = new Block();
ContextInstruction ci = new ContextInstruction(ContextInstruction.CHECK_INNER_CALL, 1000, block2);
ContextInstruction ci2 = new ContextInstruction(ContextInstruction.RESET_INNER_CALL, 1000, null);
ContextInstruction ci3 = new ContextInstruction(ContextInstruction.SET_INNER_CALL, 1000, null);
FilterAction errorAction = new FilterAction("ErrorAction", "", "");
block2.addInstruction(errorAction);
block.addInstruction(ci);
block.addInstruction(ci2);
block.addInstruction(ci3);
model.AddInputFilter("TestTarget.Program", "System.Void TestTarget.Program::TestMethod(System.Int32)", block);
// create configuration
CecilWeaverConfiguration configuration = CecilWeaverConfiguration.CreateDefaultConfiguration(CreateFullPath("TestTarget.exe"), CreateFullPath(outputFileName));
// do weaving
IILWeaver weaver = DIHelper.CreateObject <CecilILWeaver>(CreateTestContainer(model, configuration));
weaver.DoWeave();
ILReader il = new ILReader();
il.OpenAssembly(CreateFullPath(outputFileName));
List <ILInstruction> ils = il.GetILInstructions("TestTarget.Program", "TestMethod");
// Expecting the following IL code
List <ILInstruction> shouldContainThrow = new List <ILInstruction>();
shouldContainThrow.Add(new ILInstruction(0, "newobj", "System.Void System.Exception::.ctor()"));
shouldContainThrow.Add(new ILInstruction(0, "throw", ""));
Assert.IsTrue(il.ContainsILInstructions(ils, shouldContainThrow), "Generated IL code did not contain the throw exception code");
}
public async Task MatchPathAndReplaceTest()
{
var filter = this.CreateRoutingFilter(MappingStrategy.Replace);
IRequestContext context = this.CreateRequestContext("http://localhost/test");
FilterAction next = contextCheck =>
{
contextCheck.HttpClient.Should().NotBeNull();
contextCheck.Request.UrlPath.Should().Be(ReplacedPath);
contextCheck.Request.UrlHost.Should().Be(TargetHost);
return(Task.FromResult(new Mock <IResponse>().Object));
};
var response = await filter.Execute(context, next);
response.Should().NotBeNull();
}
public static FilterAction[] getFilterActions()
{
List<FilterAction> ret = new List<FilterAction>();
string result = exec("show filteraction all format=table");
if (result.Contains("IPsec[05068]"))
return new FilterAction[0];
string[] parts = result.Replace("\r", "").Split('\n');
for (int i = 2; i < parts.Length - 5; i++)
{
string part = parts[i];
string[] cells = part.Split('\t');
FilterAction filterAction = new FilterAction();
filterAction.name = cells[0].Trim();
filterAction.action = cells[1].Trim();
ret.Add(filterAction);
}
return ret.ToArray();
}
/// <summary>
/// Convert from a boolean to a visibility value.
/// </summary>
/// <param name="value">The value produced by the binding source.</param>
/// <param name="targetType">The type of the binding target property.</param>
/// <param name="parameter">The converter parameter to use.</param>
/// <param name="culture">The culture to use in the converter.</param>
/// <returns>
/// A converted value. If the method returns null, the valid null value is used.
/// </returns>
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
string convertedValue = string.Empty;
FilterAction compOperator = (FilterAction)value;
switch (compOperator)
{
case FilterAction.Include:
convertedValue = "/Resources/OK.png";
break;
case FilterAction.Exclude:
convertedValue = "/Resources/Critical.png";
break;
}
return(convertedValue);
}
public void ConstructorTest1()
{
string type = null; // TODO: Initialize to an appropriate value
string fullName = null; // TODO: Initialize to an appropriate value
string selector = null; // TODO: Initialize to an appropriate value
string target_target1 = null; // TODO: Initialize to an appropriate value
string substitutionSelector = null; // TODO: Initialize to an appropriate value
string substitutionTarget = null; // TODO: Initialize to an appropriate value
FilterAction target2 = new FilterAction(type, fullName, selector, target_target1, substitutionSelector, substitutionTarget);
// TODO: Implement code to verify target
Assert.Inconclusive("TODO: Implement code to verify target");
}
public void WeavingBeforeActionAddsPointCutContextLogic()
{
string outputFileName = "WeavingBeforeActionAddsPintCutContextLogic.exe";
// set up model
LanguageModelAccessorMock model = new LanguageModelAccessorMock();
// Create inputfilters
Block block = new Block();
Block block2 = new Block();
ContextInstruction ci = new ContextInstruction(ContextInstruction.CHECK_INNER_CALL, 1000, block2);
ContextInstruction ci2 = new ContextInstruction(ContextInstruction.RESET_INNER_CALL, 1000, null);
ContextInstruction ci3 = new ContextInstruction(ContextInstruction.SET_INNER_CALL, 1000, null);
FilterAction errorAction = new FilterAction("BeforeAction", "", "");
block2.addInstruction(errorAction);
block.addInstruction(ci);
block.addInstruction(ci2);
block.addInstruction(ci3);
model.AddInputFilter("TestTarget.Program", "System.Void TestTarget.Program::TestMethod(System.Int32)", block);
// create configuration
CecilWeaverConfiguration configuration = CecilWeaverConfiguration.CreateDefaultConfiguration(CreateFullPath("TestTarget.exe"), CreateFullPath(outputFileName));
// do weaving
IILWeaver weaver = DIHelper.CreateObject <CecilILWeaver>(CreateTestContainer(model, configuration));
weaver.DoWeave();
// Expecting the following IL code
List <ILInstruction> shouldContainBefore = new List <ILInstruction>();
shouldContainBefore.Add(new ILInstruction(0, "", ""));
shouldContainBefore.Add(new ILInstruction(0, "", ""));
// Assert.IsTrue(il.ContainsILInstructions(ils, shouldContainBefore), "Generated IL code did not contain the before action code");
Assert.Inconclusive("Add the expected IL code to make this test work.");
}
public bool KeyPress(Char key)
{
if ((key >= '0' && key <= '9') || key == '*' || key == '(' || key == '#' || key == '§')
{
// reset the list filter string
if (key == '*')
{
_listFilterString = string.Empty;
_listFilterAction = FilterAction.Contains;
}
// activate "StartsWith" function
else if ((_listFilterString == string.Empty) && (key == '0'))
{
_listFilterAction = FilterAction.StartsWith;
}
// Use StartsWith Filter
else if (_listFilterAction == FilterAction.StartsWith)
{
_listFilterString = NumPadNext(_listFilterString, key.ToString());
_text = "Starting with: " + _listFilterString.ToUpper();
}
// Add the numeric code to the list filter string
else
{
// Default
_listFilterAction = FilterAction.Contains;
_listFilterString += key.ToString();
_text = "Filtered";
}
if (Updated != null)
{
Updated(this);
}
logger.Debug("Active Filter: " + _listFilterString);
return(true);
}
return(false);
}
public async Task PipelineTestAsync()
{
FilterAction filterAction = ctx => Task.FromResult <IResponse>(null);
var filterMock1 = new Mock <IFilter>();
filterMock1.Setup(x => x.Execute(It.IsAny <IRequestContext>(), It.IsAny <FilterAction>()))
.Returns <IRequestContext, FilterAction>((ctx, next) => next(ctx));
var filterMock2 = new Mock <IFilter>();
filterMock2.Setup(x => x.Execute(It.IsAny <IRequestContext>(), It.IsAny <FilterAction>()))
.Returns <IRequestContext, FilterAction>((ctx, next) => next(ctx));
var pipeline = PipelineFactory.Create(new[] { filterMock1.Object, filterMock2.Object }, filterAction);
await pipeline(Context);
filterMock1.Verify(x => x.Execute(It.IsAny <IRequestContext>(), It.IsAny <FilterAction>()), Times.Once);
filterMock2.Verify(x => x.Execute(It.IsAny <IRequestContext>(), It.IsAny <FilterAction>()), Times.Once);
}
/// <summary>
/// Weaves the call to the advice.
/// </summary>
/// <param name="visitor">The visitor.</param>
/// <param name="filterAction">The filteraction.</param>
/// <param name="parentType">The type containing the original method.</param>
/// <param name="methodToCall">The advice method.</param>
/// <param name="jpcVar">The local variable containing the JoinPointContext.</param>
private static void CallAdvice(ICecilInliningInstructionVisitor visitor,
FilterAction filterAction, TypeDefinition parentType, MethodReference methodToCall,
VariableDefinition jpcVar)
{
// Place target on the stack:
if (methodToCall.HasThis)
{
String fargTarget = getTarget(filterAction);
if (fargTarget.Equals(FilterAction.InnerTarget) ||
fargTarget.Equals(FilterAction.SelfTarget))
{
WeaveStrategyUtilities.LoadSelfObject(visitor, jpcVar);
}
else
{
FieldDefinition target = parentType.Fields.GetField(fargTarget);
if (target == null)
{
throw new ILWeaverException(String.Format(CultureInfo.CurrentCulture,
Properties.Resources.FieldNotFound, fargTarget));
}
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldarg, visitor.Method.This));
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldfld, target));
}
}
// Load the JoinPointObject as the parameter
if (methodToCall.Parameters.Count == 1)
{
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldloc, jpcVar));
}
else if (methodToCall.Parameters.Count != 0)
{
throw new ILWeaverException(String.Format(CultureInfo.CurrentCulture,
Properties.Resources.AdviceMethodNotFound, getSelector(filterAction), getTarget(filterAction)));
}
// We can safely emit a callvirt here. The JITter will make the right call.
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Callvirt, methodToCall));
}
public Filter(FilterAction action, string initialName, bool enabled,
Search.Options options, IFiltersFactory factory)
{
this.factory = factory;
if (initialName == null)
{
throw new ArgumentNullException(nameof(initialName));
}
this.initialName = initialName;
this.enabled = enabled;
this.action = action;
this.options = options;
// Filters ignores following flags passed.
// Actually used values are provided later when filters are appied.
this.options.ReverseSearch = false;
InvalidateName();
}
public static FilterAction[] getFilterActions()
{
List <FilterAction> ret = new List <FilterAction>();
string result = exec("show filteraction all format=table");
if (result.Contains("IPsec[05068]"))
{
return(new FilterAction[0]);
}
string[] parts = result.Replace("\r", "").Split('\n');
for (int i = 2; i < parts.Length - 5; i++)
{
string part = parts[i];
string[] cells = part.Split('\t');
FilterAction filterAction = new FilterAction();
filterAction.name = cells[0].Trim();
filterAction.action = cells[1].Trim();
ret.Add(filterAction);
}
return(ret.ToArray());
}
private static FilterAction ApplyFilters(IEnumerable <IFilter> filters, SyndicationItem item)
{
// By default all items are included
FilterAction result = FilterAction.Include;
if (filters != null)
{
// All filters are executed in order of definition
foreach (var filter in filters)
{
FilterAction action = filter.Apply(item);
if (action != FilterAction.None)
{
// The result is only changed when the filter "applies"
result = action;
}
}
}
return(result);
}
protected bool KeyPress(Char key)
{
if ((key >= '0' && key <= '9') || key == '*' || key == '(' || key == '#' || key == '§')
{
// reset the list filter string
if (key == '*')
{
_listFilterString = string.Empty;
_listFilterAction = FilterAction.Contains;
}
// activate "StartsWith" function
else if ((_listFilterString == string.Empty) && (key == '0'))
{
_listFilterAction = FilterAction.StartsWith;
}
// Use StartsWith Filter
else if (_listFilterAction == FilterAction.StartsWith)
{
_listFilterString = NumPadNext(_listFilterString, key.ToString());
_text = ServiceRegistration.Get <ILocalization>().ToString("[Filter.StartsWith]", _listFilterString.ToUpper());
}
// Add the numeric code to the list filter string
else
{
// Default
_listFilterAction = FilterAction.Contains;
_listFilterString += key.ToString();
_text = ServiceRegistration.Get <ILocalization>().ToString("[Filter.Filtered]", _listFilterString.ToUpper());
}
ServiceRegistration.Get <ILogger>().Debug("Active Filter: {0}", _listFilterString);
return(true);
}
return(false);
}
public FilterAction CreateFilterAction(FilterAction lastAction, IEnumerable <string> filters)
{
if (lastAction == null)
{
throw new ArgumentNullException(nameof(lastAction));
}
if (filters == null || filters.Any() == false)
{
return(lastAction);
}
var filtersInstances = filters.Reverse().Select(x =>
{
if (!this.filtersDictionary.TryGetValue(x, out var filertData))
{
throw new InvalidOperationException($"Cannot find filter for name {x}");
}
return(filertData.Item1);
});
return(PipelineFactory.Create(filtersInstances, lastAction));
}
/// <summary>
/// Generate the code which has to be inserted at the place of the filter specified by the visitor.
/// </summary>
/// <param name="visitor">The visitor.</param>
/// <param name="filterAction">The filter action.</param>
/// <param name="originalCall">The original call.</param>
public override void Weave(ICecilInliningInstructionVisitor visitor, FilterAction filterAction,
MethodDefinition originalCall)
{
MethodReference methodToCall;
// Get JoinPointContext
VariableDefinition jpcVar = visitor.CreateJoinPointContextLocal();
// Get the methodReference
MethodReference methodReference = (MethodReference)originalCall;
TypeDefinition parentType = CecilUtilities.ResolveTypeDefinition(visitor.Method.DeclaringType);
// Get method to call
methodToCall = GetMethodToCall(visitor, filterAction, parentType);
if (methodToCall == null)
{
throw new ILWeaverException(String.Format(CultureInfo.CurrentCulture,
Properties.Resources.AdviceMethodNotFound, getSelector(filterAction), getTarget(filterAction)));
}
// Set JoinPointContext
WeaveStrategyUtilities.SetJoinPointContext(visitor, methodReference, filterAction);
// Check if it is an innercall and set innercall context:
if (getTarget(filterAction).Equals(FilterAction.InnerTarget))
{
WeaveStrategyUtilities.SetInnerCall(visitor, methodToCall);
}
// Do the advice-call
AdviceActionWeaveStrategy.CallAdvice(visitor, filterAction, parentType, methodToCall, jpcVar);
// Add nop to enable debugging
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Nop));
}
protected bool KeyPress(Char key)
{
if ((key >= '0' && key <= '9') || key == '*' || key == '(' || key == '#' || key == '§')
{
// reset the list filter string
if (key == '*')
{
_listFilterString = string.Empty;
_listFilterAction = FilterAction.Contains;
}
// activate "StartsWith" function
else if ((_listFilterString == string.Empty) && (key == '0'))
{
_listFilterAction = FilterAction.StartsWith;
}
// Use StartsWith Filter
else if (_listFilterAction == FilterAction.StartsWith)
{
_listFilterString = NumPadNext(_listFilterString, key.ToString());
_text = ServiceRegistration.Get<ILocalization>().ToString("[Filter.StartsWith]", _listFilterString.ToUpper());
}
// Add the numeric code to the list filter string
else
{
// Default
_listFilterAction = FilterAction.Contains;
_listFilterString += key.ToString();
_text = ServiceRegistration.Get<ILocalization>().ToString("[Filter.Filtered]", _listFilterString.ToUpper());
}
ServiceRegistration.Get<ILogger>().Debug("Active Filter: {0}", _listFilterString);
return true;
}
return false;
}
public static void addFilterRule(string name, FilterPolicy policy, FilterList list, FilterAction action)
{
string s = exec("add rule name=\"" + name + "\" policy=\"" + policy.name + "\" filterlist=\"" + list.name + "\" filteraction=\"" + action.name + "\"");
}
protected Validator(string name, ValidatorType type, FilterAction action)
{
this.Name = name ?? throw new ArgumentNullException(nameof(name));
this.Type = type;
this.Action = action;
}
public Filter(FilterAction action, FeedField field)
{
this.Action = action;
this.Field = field;
}
private static extern int Unmanaged_ConfigureFilter(FilterType filter, FilterAction action, IntPtr data);
public int iV_ConfigureFilter(FilterType filter, FilterAction action, IntPtr data)
{
return Unmanaged_ConfigureFilter(filter, action, data);
}
public HeaderFilter(List<string> regexes, FilterAction action)
{
this.Regexes = regexes;
this.Action = action;
}
public static void addFilterRule(string name, FilterPolicy policy, FilterList list, FilterAction action)
{
string s = exec("add rule name=\"" + name + "\" policy=\"" + policy.name + "\" filterlist=\"" + list.name + "\" filteraction=\"" + action.name + "\"");
}
public RegexFilter(Regex regex, FilterAction filterAction)
{
if (regex == null)
throw new ArgumentNullException ("regex");
_regex = regex;
_filterAction = filterAction;
}
public static RegexFilter Parse(string s, FilterAction filterAction)
{
if (string.IsNullOrEmpty (s))
throw new ArgumentException ("Filter string cannot be null or empty", "s");
string pattern;
if (s.Length > 1 && s.StartsWith ("/") && s.EndsWith ("/")) {
pattern =s.Substring(1, s.Length - 2);
} else {
pattern = string.Join ("", ".*", s, ".*");
}
var regex = new Regex (pattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);
return new RegexFilter (regex, filterAction);
}
public static void SetJoinPointContext(
ICecilInliningInstructionVisitor visitor,
MethodReference originalCall, FilterAction filterAction)
{
VariableDefinition jpcVar = visitor.CreateJoinPointContextLocal();
// Store current target
if (filterAction.Target.Equals(FilterAction.InnerTarget) ||
filterAction.Target.Equals(FilterAction.SelfTarget))
{
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldloc, jpcVar));
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldloc, jpcVar));
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Callvirt,
CecilUtilities.CreateMethodReference(visitor.TargetAssemblyDefinition,
CachedMethodDefinition.JoinPointContextGetStartTarget)));
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Callvirt,
CecilUtilities.CreateMethodReference(visitor.TargetAssemblyDefinition,
CachedMethodDefinition.JoinPointContextSetCurrentTarget)));
}
else if (visitor.Method.HasThis)
{
TypeDefinition parentType = CecilUtilities.ResolveTypeDefinition(visitor.Method.DeclaringType);
FieldDefinition field = parentType.Fields.GetField(filterAction.Target);
if (field == null)
{
throw new ILWeaverException(String.Format(CultureInfo.CurrentCulture,
Properties.Resources.FieldNotFound, filterAction.Target));
}
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldloc, jpcVar));
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldarg, visitor.Method.This));
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldfld, field));
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Callvirt,
CecilUtilities.CreateMethodReference(visitor.TargetAssemblyDefinition,
CachedMethodDefinition.JoinPointContextSetCurrentTarget)));
}
else
{
// set to null for static methods
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldloc, jpcVar));
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldnull));
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Callvirt,
CecilUtilities.CreateMethodReference(visitor.TargetAssemblyDefinition,
CachedMethodDefinition.JoinPointContextSetCurrentTarget)));
}
// store current selector
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldloc, jpcVar));
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldstr, filterAction.Selector));
visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Callvirt,
CecilUtilities.CreateMethodReference(visitor.TargetAssemblyDefinition,
CachedMethodDefinition.JoinPointContextSetCurrentSelector)));
// Store substitution target
//if (filterAction.SubstitutionTarget.Equals(FilterAction.InnerTarget) ||
// filterAction.SubstitutionTarget.Equals(FilterAction.SelfTarget))
//{
// visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldloc, jpcVar));
// visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldloc, jpcVar));
// visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Callvirt,
// CecilUtilities.CreateMethodReference(visitor.TargetAssemblyDefinition,
// CachedMethodDefinition.JoinPointContextGetStartTarget)));
// visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Callvirt,
// CecilUtilities.CreateMethodReference(visitor.TargetAssemblyDefinition,
// CachedMethodDefinition.JoinPointContextGetSubstitutionTarget)));
//}
//else if (visitor.Method.HasThis)
//{
// TypeDefinition parentType = CecilUtilities.ResolveTypeDefinition(visitor.Method.DeclaringType);
// FieldDefinition field = parentType.Fields.GetField(filterAction.SubstitutionTarget);
// if (field == null)
// {
// throw new ILWeaverException(String.Format(CultureInfo.CurrentCulture,
// Properties.Resources.FieldNotFound, filterAction.SubstitutionTarget));
// }
// visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldloc, jpcVar));
// visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldarg, visitor.Method.This));
// visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldfld, field));
// visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Callvirt,
// CecilUtilities.CreateMethodReference(visitor.TargetAssemblyDefinition,
// CachedMethodDefinition.JoinPointContextSetSubstitutionTarget)));
//}
//else
//{
// // set to null for static methods
// visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldloc, jpcVar));
// visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldnull));
// visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Callvirt,
// CecilUtilities.CreateMethodReference(visitor.TargetAssemblyDefinition,
// CachedMethodDefinition.JoinPointContextSetSubstitutionTarget)));
//}
// store substitution selector
// TODO no longer relevant
//visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldloc, jpcVar));
//visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Ldstr, filterAction.SubstitutionSelector));
//visitor.Instructions.Add(visitor.Worker.Create(OpCodes.Callvirt,
// CecilUtilities.CreateMethodReference(visitor.TargetAssemblyDefinition,
// CachedMethodDefinition.JoinPointContextSetSubstitutionSelector)));
}
public FilterActionEntry(FilterAction propertyAction)
{
this.propertyAction = propertyAction;
}
public bool IsFilterAuthorized(ushort key, HDestination destination, FilterAction action)
{
return(!_blocked[destination].Contains(key) &&
!_replacements[destination].ContainsKey(key));
}
public RemoteNumpadFilter()
{
_listFilterString = string.Empty;
_listFilterAction = FilterAction.Contains;
CreateKeyMap();
}
public TestDependenciesSnapshotFilter ImplementBeforeRemoveResult(FilterAction action, string id, IDependency dependency)
{
_beforeRemove.Add(id, Tuple.Create(dependency, action));
return(this);
}
/// <summary>
/// Filter bitmap with the Fastest Fourier Transform
/// </summary>
/// <returns>Blurred bitmap</returns>
private double[,,] Apply(double[,,] imageData, FilterAction filterAction)
{
Complex f = Complex.One;
int length = imageData.Length; // Image length = height*width*colors
int n0 = imageData.GetLength(0); // Image height
int n1 = imageData.GetLength(1); // Image width
int n2 = imageData.GetLength(2); // Image colors
var kernelFourier = new Complex[n0, n1]; // Filter values
GetKernelFourier(kernelFourier);
// Filter main loop
var doubles = new double[length];
Buffer.BlockCopy(imageData, 0, doubles, 0, length*sizeof (double));
double average;
double delta;
AverageAndDelta(out average, out delta, doubles, _keepOption);
Complex[] complex = doubles.Select(x => new Complex(x, 0)).ToArray();
Fourier(n0, n1, n2, complex, FourierDirection.Forward);
// Apply filter values
int index = 0;
switch (filterAction)
{
case FilterAction.Multiply:
for (int i = 0; i < n0; i++)
for (int j = 0; j < n1; j++)
{
Complex value = kernelFourier[i, j];
for (int k = 0; k < n2; k++)
complex[index++] *= f + value;
}
break;
case FilterAction.Divide:
for (int i = 0; i < n0; i++)
for (int j = 0; j < n1; j++)
{
Complex value = kernelFourier[i, j];
for (int k = 0; k < n2; k++)
complex[index++] /= f + value;
}
break;
default:
throw new NotImplementedException();
}
Fourier(n0, n1, n2, complex, FourierDirection.Backward);
doubles = complex.Select(x => x.Magnitude/length).ToArray();
double average2;
double delta2;
AverageAndDelta(out average2, out delta2, doubles, _keepOption);
// a*average2 + b == average
// a*delta2 == delta
double a = (_keepOption == KeepOption.AverageAndDelta) ? (delta/delta2) : (average/average2);
double b = (_keepOption == KeepOption.AverageAndDelta) ? (average - a*average2) : 0;
Debug.Assert(Math.Abs(a*average2 + b - average) < 0.1);
doubles = doubles.Select(x => Math.Round(a*x + b)).ToArray();
Buffer.BlockCopy(doubles, 0, imageData, 0, length*sizeof (double));
return imageData;
}
