public System.Collections.Specialized.StringCollection Extract()
{
String strPattern = "([A-Za-z0-9](([_\\.\\-]?[a-zA-Z0-9]+)*)@([A-Za-z0-9]+)(([\\.\\-]?[a-zA-Z0-9]+)*)\\.([A-Za-z]{2,}))";
System.Collections.Specialized.StringCollection collAddresses = new System.Collections.Specialized.StringCollection();
INodeFilter filter = new RegexFilter(strPattern, true);
NodeList nodes = m_obParser.Parse(filter);
if (null != nodes &&
0 != nodes.Size())
{
RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.Multiline;
Regex obRegex = new Regex(strPattern, options);
for (Int32 i = 0; i < nodes.Size(); i++)
{
INode obNode = nodes.ElementAt(i);
String strText = obNode.GetText();
Match m = obRegex.Match(strText);
while (m.Success)
{
collAddresses.Add(m.Groups[0].Value);
// Advance to the next match.
m = m.NextMatch();
}
}
}
return(collAddresses);
}
public void Matches(string expressionToMatch, RegexOptions regexOptions)
{
string someExpression = "A*b+";
RegexFilter filter = new RegexFilter(new Regex(someExpression, regexOptions));
Assert.AreEqual(filter.ToString(), "Regex('" + someExpression + "', " + regexOptions + ")");
Assert.IsTrue(filter.IsMatch(expressionToMatch));
}
public void Constructor_WithValues_PropertiesAreSet()
{
var filter = new RegexFilter("test_dimension", "\\d");
Assert.That(filter.Dimension, Is.EqualTo("test_dimension"));
Assert.That(filter.Pattern, Is.EqualTo("\\d"));
}
public async Task <IEnumerable <TemplateDto> > SearchForUserTemplates(ObjectId userID, string query)
{
try
{
await database.Connect().ConfigureAwait(false);
var userFilter = new EqualityFilter <ObjectId>("authorID", userID);
var nameFilter = new RegexFilter("name", query);
var getFilter = userFilter & nameFilter;
var templates = await database.Get(getFilter).ConfigureAwait(false);
var author = await userService.GetAsync(userID);
if (author is null)
{
throw new ArgumentException("No user fot given ID");
}
return(templates.Select(template => new TemplateDto(template, author)));
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error ocurred while searching for templates");
}
}
public async Task <IEnumerable <TemplateDto> > SearchForPublishedTemplates(string query)
{
try
{
await database.Connect().ConfigureAwait(false);
RegexFilter nameFilter = new RegexFilter("name", query);
var templates = await database.Get(nameFilter).ConfigureAwait(false);
IDictionary <ObjectId, UserInfo> users = templates.Select(template => template.AuthorID).ToHashSet()
.Select(id =>
{
if (userService.GetAsync(id).GetAwaiter().GetResult() is {} user)
{
return(user);
}
throw new ArgumentException("No user fo given ID");
})
.ToDictionary(u => u.ID, u => u);
return(templates.Select(template => new TemplateDto(template, users[template.AuthorID])));
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error ocurred while searching for published templates");
}
}
public void NoMatches(string expressionToMatch)
{
string someExpression = "A*b+";
RegexFilter filter = new RegexFilter(new Regex(someExpression));
Assert.AreEqual(filter.ToString(), "Regex('" + someExpression + "', None)");
Assert.IsFalse(filter.IsMatch(expressionToMatch));
}
public RegexFilterTests(ITestOutputHelper output)
{
this.logger = output.BuildLogger();
this.filter = new RegexFilter();
this.servers = new Server[] {
new ShadowsocksServer()
{
Name = "goodserver 1"
},
new ShadowsocksServer()
{
Name = "goodserver 2"
},
new ShadowsocksServer()
{
Name = "goodserver 3"
},
new ShadowsocksServer()
{
Name = "badserver 1"
},
new ShadowsocksServer()
{
Name = "badserver 2"
},
};
}
public void ToStringTest()
{
string someExpression = "Some Expression *";
RegexFilter filter = new RegexFilter(new Regex(someExpression));
Assert.AreEqual(filter.ToString(), "Regex('" + someExpression + "', None)");
}
public int Execute (String inputFilePath, String outputFilePath, RegexFilter craftFilter, RegexFilter partFilter)
{
ui.DisplayUserMessage ($"Searching for crafts matching '{craftFilter}'...");
var kspObjTree = CraftLoader.LoadFromFile (inputFilePath);
var crafts = new CraftLookup (kspObjTree).LookupCrafts (craftFilter).ToList ();
if (crafts.Count <= 0) {
ui.DisplayErrorMessage ($"No craft matching '{craftFilter}' found, aborting");
return -1;
}
ui.DisplayUserMessage ($"Searching for parts matching '{partFilter}'...");
var partsRemoved = crafts.Aggregate (false, (removed, craft) => removed | RemoveMatchingParts (craft, partFilter));
if (!partsRemoved) {
ui.DisplayErrorMessage ($"No parts removed");
return -1;
}
CraftLoader.SaveToFile (outputFilePath, kspObjTree);
return 0;
}
internal void ApplyParameterFilters(
SpecimenProvider specimenProvider,
RegexFilter filter)
{
// Arrange
filter.IncludeMethod("Compare", typeof(Uri))
.ExcludeParameter("uri1", typeof(Uri))
.ExcludeParameter("uri2", typeof(Uri), "Compare")
.Rules.Add(new RegexRule("exclude all", type: new Regex(".*"), method: new Regex(".*")));
IArgumentNullExceptionFixture sut =
new ArgumentNullExceptionFixture(typeof(Uri).GetTypeInfo().Assembly,
specimenProvider,
new List <IFilter> {
filter
},
new List <IMapping>());
// Act
List <MethodData> methodDatas = sut.GetData().ToList();
// Assert
Assert.Equal(3, methodDatas.Count);
Assert.Equal(3, methodDatas.Select(m => m.ExecutionSetup).OfType <DefaultExecutionSetup>().Count());
}
public void CreateErroredMethodInvocationData(
Mock <ISpecimenProvider> specimenProviderMock,
FileNotFoundException exception,
RegexFilter filter)
{
// Arrange
specimenProviderMock.Setup(sp => sp.GetParameterSpecimens(It.IsAny <IList <ParameterInfo> >(), It.IsAny <int>()))
.Throws(exception);
filter.IncludeMethod("Compare", typeof(Uri))
.Rules.Add(new RegexRule("exclude all", type: new Regex(".*"), method: new Regex(".*")));
IArgumentNullExceptionFixture sut =
new ArgumentNullExceptionFixture(typeof(Uri).GetTypeInfo().Assembly,
specimenProviderMock.Object,
new List <IFilter> {
filter
},
new List <IMapping>());
// Act
List <MethodData> methodDatas = sut.GetData().ToList();
// Assert
Assert.Equal(5, methodDatas.Count);
List <ErroredExecutionSetup> executionSetups = methodDatas.Select(m => m.ExecutionSetup).OfType <ErroredExecutionSetup>().ToList();
Assert.Equal(5, executionSetups.Count);
foreach (ErroredExecutionSetup executionSetup in executionSetups)
{
CompositionException compositionException = Assert.IsType <CompositionException>(executionSetup.Exception);
Assert.Same(exception, compositionException.InnerException);
}
}
public SigInfo(string extension, params string[] signatures)
{
this.Extension = extension;
this.Signature = new short[signatures.Length][];
int i, j;
for (i = 0; i < signatures.Length; ++i)
{
signatures[i] = RegexFilter.Replace(signatures[i], "");
var buff = new short[signatures[i].Length / 2];
for (j = 0; j < buff.Length; ++j)
{
var part = signatures[i].Substring(j * 2, 2);
if (part == "??")
{
buff[j] = -1;
}
else
{
buff[j] = byte.Parse(part, NumberStyles.HexNumber);
}
}
this.Signature[i] = buff;
}
Array.Sort(this.Signature, (a, b) => a.Length.CompareTo(b.Length) * -1);
}
public int Execute(String inputFilePath, String outputFilePath, RegexFilter craftFilter, RegexFilter partFilter)
{
ui.DisplayUserMessage($"Searching for crafts matching '{craftFilter}'...");
var kspObjTree = CraftLoader.LoadFromFile(inputFilePath);
var crafts = new CraftLookup(kspObjTree).LookupCrafts(craftFilter).ToList();
if (crafts.Count <= 0)
{
ui.DisplayErrorMessage($"No craft matching '{craftFilter}' found, aborting");
return(-1);
}
ui.DisplayUserMessage($"Searching for parts matching '{partFilter}'...");
var partsRemoved = crafts.Aggregate(false, (removed, craft) => removed | RemoveMatchingParts(craft, partFilter));
if (!partsRemoved)
{
ui.DisplayErrorMessage($"No parts removed");
return(-1);
}
CraftLoader.SaveToFile(outputFilePath, kspObjTree);
return(0);
}
public void UnnamedGroup()
{
var environment = new Environment();
var filter = new RegexFilter(@"^file(\d+)\.txt$");
var file = new DummyFile("file456.txt");
filter.IsMatch(file, environment);
Assert.AreEqual("456", environment.Get("1"));
}
public void NoMatches(string expressionToMatch)
{
string someExpression = "A*b+";
RegexFilter filter = new RegexFilter(new Regex(someExpression));
Assert.AreEqual(filter.ToString(), "Regex('" + someExpression + "', None)");
Assert.IsFalse(filter.IsMatch(expressionToMatch));
}
public void Matches(string expressionToMatch, RegexOptions regexOptions)
{
string someExpression = "A*b+";
RegexFilter filter = new RegexFilter(new Regex(someExpression, regexOptions));
Assert.AreEqual(filter.ToString(), "Regex('" + someExpression + "', " + regexOptions + ")");
Assert.IsTrue(filter.IsMatch(expressionToMatch));
}
public void UnnamedGroup()
{
var environment = new Environment();
var filter = new RegexFilter(@"^file(\d+)\.txt$");
var file = new DummyFile("file456.txt");
filter.IsMatch(file, environment);
Assert.AreEqual("456", environment.Get("1"));
}
public void SupportsInverseMatching ()
{
// given
var target = new RegexFilter ("![Bb]ert");
// when / then
Assert.That (target.Matches ("Herbert"), Is.False);
Assert.That (target.Matches ("Berthold"), Is.False);
Assert.That (target.Matches ("Franz"), Is.True);
}
public IEnumerable<KspPartObject> LookupParts (RegexFilter partFilter)
{
int id;
if (int.TryParse (partFilter.Pattern, out id)) {
var dependency = craft.Child<KspPartObject> (id);
return dependency != null ? new[] { dependency } : Enumerable.Empty<KspPartObject> ();
}
return partFilter.Apply (craft.Children <KspPartObject> (), part => part.Name);
}
public void SupportsInverseMatching()
{
// given
var target = new RegexFilter("![Bb]ert");
// when / then
Assert.That(target.Matches("Herbert"), Is.False);
Assert.That(target.Matches("Berthold"), Is.False);
Assert.That(target.Matches("Franz"), Is.True);
}
private List <KspPartObject> FindParts(KspCraftObject craft, RegexFilter filter)
{
ui.DisplayUserMessage($"Entering craft '{craft.Name}'...");
var partLookup = new PartLookup(craft);
var parts = partLookup.LookupParts(filter).ToList();
ui.DisplayUserMessage($"Found {parts.Count} matching parts");
return(parts);
}
private List<KspPartObject> FindParts (KspCraftObject craft, RegexFilter filter)
{
ui.DisplayUserMessage ($"Entering craft '{craft.Name}'...");
var partLookup = new PartLookup (craft);
var parts = partLookup.LookupParts (filter).ToList ();
ui.DisplayUserMessage ($"Found {parts.Count} matching parts");
return parts;
}
public static void AddFileFilterRegex(this FilterOptions options, string regexPattern, bool negateFilter = false)
{
var filter = new RegexFilter(regexPattern);
if (negateFilter)
{
filter.NegateFilter();
}
options.AddFileFilters(filter);
}
public virtual string GetRemoteCommand()
{
if (!HasRemoteCommand)
{
return(null);
}
return(string.IsNullOrEmpty(Filter?.RepositoryFilter)
? null /* makes no sense */
: $"list:{RegexFilter.Get(Filter.RepositoryFilter)}");
}
public Rule Regex(string regex, string errorMsg = "重复")
{
var filter = new RegexFilter()
{
ErrorMsg = errorMsg,
RegexString = regex
};
Filters.Add(filter);
return(this);
}
internal RegexControl(RegexFilter filter = null)
: base(filter)
{
InitializeComponent();
RegexBox.Text = filter.Regex.ToString();
checkIgnoreCase.Checked = (filter.Regex.Options & RegexOptions.IgnoreCase) != 0;
checkSingleLine.Checked = (filter.Regex.Options & RegexOptions.Singleline) != 0;
checkMultiline.Checked = (filter.Regex.Options & RegexOptions.Multiline) != 0;
checkIgnorePatternWhitespace.Checked = (filter.Regex.Options & RegexOptions.IgnorePatternWhitespace) != 0;
checkExplicitCapture.Checked = (filter.Regex.Options & RegexOptions.ExplicitCapture) != 0;
checkRightToLeft.Checked = (filter.Regex.Options & RegexOptions.RightToLeft) != 0;
}
public int Execute (String inputFilePath, RegexFilter craftFilter)
{
ui.DisplayUserMessage ($"Searching for crafts matching '{craftFilter}'...");
var kspObjTree = CraftLoader.LoadFromFile (inputFilePath);
var crafts = new CraftLookup (kspObjTree).LookupCrafts (craftFilter).ToList ();
if (crafts.Count > 0) {
ui.DisplayCraftList (crafts);
}
return 0;
}
public void ShouldNotThrow()
{
var filter = new RegexFilter();
filter.ExcludeAllTypes().IncludeType(typeof(InternalInnerInterface));
List <MethodBase> methods =
typeof(InternalInnerInterface).GetMethods(
BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.DeclaredOnly,
new[] { filter }).ToList();
Assert.NotNull(methods);
Assert.NotEmpty(methods);
}
internal RegexControl(RegexFilter filter = null)
: base(filter)
{
InitializeComponent();
RegexBox.Text = filter.Regex.ToString();
checkIgnoreCase.Checked = (filter.Regex.Options & RegexOptions.IgnoreCase) != 0;
checkSingleLine.Checked = (filter.Regex.Options & RegexOptions.Singleline) != 0;
checkMultiline.Checked = (filter.Regex.Options & RegexOptions.Multiline) != 0;
checkIgnorePatternWhitespace.Checked = (filter.Regex.Options & RegexOptions.IgnorePatternWhitespace) != 0;
checkExplicitCapture.Checked = (filter.Regex.Options & RegexOptions.ExplicitCapture) != 0;
checkRightToLeft.Checked = (filter.Regex.Options & RegexOptions.RightToLeft) != 0;
}
public void RegexTransform_MatchesFirstInteger()
{
var SUT = new RegexFilter("\\d+", RegexReturnTypeEnum.FirstMatch, "");
string result = null;
SUT.EmitData += (sender, args) =>
{
result = args.Data;
};
SUT.DataHandler.Invoke(this, new EmitDataHandlerArgs("Test 12 Data 14"));
Assert.That(result == "12");
}
public int Execute(String inputFilePath, RegexFilter craftFilter)
{
ui.DisplayUserMessage($"Searching for crafts matching '{craftFilter}'...");
var kspObjTree = CraftLoader.LoadFromFile(inputFilePath);
var crafts = new CraftLookup(kspObjTree).LookupCrafts(craftFilter).ToList();
if (crafts.Count > 0)
{
ui.DisplayCraftList(crafts);
}
return(0);
}
public void CanApplyRegularExpressionFilterOnCollection()
{
// given
var target = new RegexFilter("[Bb]ert");
var herbert = new { Name = "Herbert" };
var franz = new { Name = "Franz" };
var berthold = new { Name = "Berthold" };
// when
var filtered = target.Apply(new[] { herbert, franz, berthold }, user => user.Name);
// then
Assert.That(filtered, Is.EquivalentTo(new[] { herbert, berthold }));
}
public void CanApplyRegularExpressionFilterOnCollection ()
{
// given
var target = new RegexFilter ("[Bb]ert");
var herbert = new {Name = "Herbert"};
var franz = new {Name = "Franz"};
var berthold = new {Name = "Berthold"};
// when
var filtered = target.Apply (new[] { herbert, franz, berthold }, user => user.Name);
// then
Assert.That (filtered, Is.EquivalentTo (new[] { herbert, berthold }));
}
public int Execute (String inputFilePath, RegexFilter craftFilter, RegexFilter partFilter)
{
ui.DisplayUserMessage ($"Searching for crafts matching '{craftFilter}'...");
var kspObjTree = CraftLoader.LoadFromFile (inputFilePath);
var crafts = new CraftLookup (kspObjTree).LookupCrafts (craftFilter);
ui.DisplayUserMessage ($"Searching for parts matching '{partFilter}'...");
var filteredParts = crafts.ToDictionary (craft => craft, craft => FindParts (craft, partFilter));
if (filteredParts.Any (entry => entry.Value.Count > 0)) {
ui.DisplayPartList (filteredParts);
}
return 0;
}
public void AddReplaceString(String refID, String replacment, String pattern, int lines)
{
if (!this.Project.DataTypeReferences.Contains(refID))
{
throw new BuildException(String.Format("The refid {0} is not defined.", refID));
}
FilterChain RefFilterChain = (FilterChain)this.Project.DataTypeReferences[refID];
RegexFilter Regex = new RegexFilter();
Regex.Lines = lines;
Regex.Pattern = pattern;
Regex.Replacment = replacment;
RefFilterChain.Filters.Add(Regex);
}
public async Task <IEnumerable <UserInfo> > FindUsersWithLoginAsync(string login)
{
try
{
await database.Connect();
string bsonPropertyName = typeof(UserInfo).GetBsonPropertyName("Login");
var filter = new RegexFilter(bsonPropertyName, $"/{login}/");
return(await database.Get(filter));
}
catch (Exception ex)
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error occured when searching for users");
}
}
public async Task <IEnumerable <DocumentFolder> > GetFolders(ObjectId userID, string searchQuery)
{
try
{
await database.Connect().ConfigureAwait(false);
FilterBase idFilter = new EqualityFilter <ObjectId>(typeof(DocumentFolder).GetBsonPropertyName("ID"), userID);
FilterBase folderNameFilter = new RegexFilter(typeof(DocumentFolder).GetBsonPropertyName("FolderName"), $"/{searchQuery}/");
return(await database.Get(idFilter& folderNameFilter).ConfigureAwait(false));
}
catch (Exception ex)
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("The error occured while searching for folders");
}
}
public void RewriteNiceHrefHtmlIsValid()
{
String testString = "<a href=\"/something/blah.aspx\">Link Name</a>" + " </html>";
Byte[] bytes = UTF8Encoding.UTF8.GetBytes(testString);
MemoryStream stream = new MemoryStream();
stream.Write(bytes, 0, bytes.Length);
RegexFilter testFilter = new RegexFilter(stream, tokenName, tokenValue);
testFilter.Write(bytes, 0, bytes.Length);
String responseHtml = testFilter.GetResponseHtml.ToString();
Assert.AreNotEqual(testString, responseHtml,
"responseHtml was not modified by the filter. It is still: {0}",
responseHtml);
}
public void RewriteFormEndTagIsValid()
{
String testString = "</form>" + " </html>";
Byte[] bytes = UTF8Encoding.UTF8.GetBytes(testString);
MemoryStream stream = new MemoryStream();
stream.Write(bytes, 0, bytes.Length);
RegexFilter testFilter = new RegexFilter(stream, tokenName, tokenValue);
testFilter.Write(bytes, 0, bytes.Length);
String responseHtml = testFilter.GetResponseHtml.ToString();
// strings must not be the same, else that means no filtering happened
Assert.AreNotEqual(testString, responseHtml,
"responseHtml was not modified by the filter. It is still: {0}",
responseHtml);
}
public int Execute(String inputFilePath, RegexFilter craftFilter, RegexFilter partFilter)
{
ui.DisplayUserMessage($"Searching for crafts matching '{craftFilter}'...");
var kspObjTree = CraftLoader.LoadFromFile(inputFilePath);
var crafts = new CraftLookup(kspObjTree).LookupCrafts(craftFilter);
ui.DisplayUserMessage($"Searching for parts matching '{partFilter}'...");
var filteredParts = crafts.ToDictionary(craft => craft, craft => FindParts(craft, partFilter));
if (filteredParts.Any(entry => entry.Value.Count > 0))
{
ui.DisplayPartList(filteredParts);
}
return(0);
}
private bool RemoveMatchingParts (KspCraftObject craft, RegexFilter partFilter)
{
var toBeRemoved = FindRemovedAndDependentParts (craft, partFilter);
if (toBeRemoved.Count <= 0) {
return false;
}
ui.DisplayUserList ("Removed Parts", toBeRemoved.Select (part => ProgramUI.PartObjectToString (craft, part)));
var removeConfirmed = ui.AskYesNoQuestion ("Remove the listed parts?");
if (removeConfirmed) {
craft.Edit ().RemoveParts (toBeRemoved);
ui.DisplayUserMessage ($"{toBeRemoved.Count} parts removed");
}
return removeConfirmed;
}
public void RewriteHrefHtmlWithInconsistentSpaces()
{
String testString = "<a href = \"/something/blah.aspx\">Link Name</a>" + " </html>";
Byte[] bytes = UTF8Encoding.UTF8.GetBytes(testString);
MemoryStream stream = new MemoryStream();
stream.Write(bytes, 0, bytes.Length);
RegexFilter testFilter = new RegexFilter(stream, tokenName, tokenValue);
testFilter.Write(bytes, 0, bytes.Length);
String responseHtml = testFilter.GetResponseHtml.ToString();
Assert.AreNotEqual(testString, responseHtml,
"responseHtml was not modified by the filter. It is still: {0}",
responseHtml);
}
public void RewriteFormEndTagIsValid()
{
String testString = "</form>" + " </html>";
Byte[] bytes = UTF8Encoding.UTF8.GetBytes(testString);
MemoryStream stream = new MemoryStream();
stream.Write(bytes, 0, bytes.Length);
RegexFilter testFilter = new RegexFilter(stream, tokenName, tokenValue);
testFilter.Write(bytes, 0, bytes.Length);
String responseHtml = testFilter.GetResponseHtml.ToString();
// strings must not be the same, else that means no filtering happened
Assert.AreNotEqual(testString, responseHtml,
"responseHtml was not modified by the filter. It is still: {0}",
responseHtml);
}
private Dictionary<KspPartObject, List<KspPartLinkProperty>> FindPartDependencies (KspCraftObject craft, RegexFilter filter)
{
ui.DisplayUserMessage ($"Entering craft '{craft.Name}'...");
var partLookup = new PartLookup (craft);
var dependencies = partLookup.LookupParts (filter).ToList ();
var dependentParts = new HashSet<KspPartObject> ();
Parallel.ForEach (dependencies, dependency => {
foreach (var part in partLookup.LookupSoftDependencies (dependency)) {
lock (dependentParts) {
dependentParts.Add (part);
}
}
});
ui.DisplayUserMessage ($"Found {dependentParts.Count} dependent parts");
return dependentParts.ToDictionary (part => part, part => FindPartLinks (part, dependencies));
}
private bool RemoveMatchingParts(KspCraftObject craft, RegexFilter partFilter)
{
var toBeRemoved = FindRemovedAndDependentParts(craft, partFilter);
if (toBeRemoved.Count <= 0)
{
return(false);
}
ui.DisplayUserList("Removed Parts", toBeRemoved.Select(part => ProgramUI.PartObjectToString(craft, part)));
var removeConfirmed = ui.AskYesNoQuestion("Remove the listed parts?");
if (removeConfirmed)
{
craft.Edit().RemoveParts(toBeRemoved);
ui.DisplayUserMessage($"{toBeRemoved.Count} parts removed");
}
return(removeConfirmed);
}
private List<KspPartObject> FindRemovedAndDependentParts (KspCraftObject craft, RegexFilter filter)
{
ui.DisplayUserMessage ($"Entering craft '{craft.Name}'...");
var partLookup = new PartLookup (craft);
var removedParts = partLookup.LookupParts (filter).ToList ();
ui.DisplayUserMessage ($"Found {removedParts.Count} parts to be removed");
var dependentParts = new HashSet<KspPartObject> ();
Parallel.ForEach (removedParts, removedPart => {
foreach (var part in partLookup.LookupHardDependencies (removedPart).Except (removedParts)) {
lock (dependentParts) {
dependentParts.Add (part);
}
}
});
ui.DisplayUserMessage ($"Found {dependentParts.Count} dependent parts");
return removedParts.Concat (dependentParts).ToList ();
}
private void AddFilter(RegexFilter regex)
{
filterList.Add (regex);
//Get continous strings from pattern
string[] parts = regex.Wildcard.Split (wildcards);
bool added = false;
foreach (string part in parts) {
if (part.Length == 0)
continue;
if (part.Length > 8) {
try {
hashList [part].Add (regex);
} catch (KeyNotFoundException) {
List<RegexFilter > list = new List<RegexFilter> ();
list.Add (regex);
hashList.Add (part, list);
}
added = true;
}
}
if (added == false)
hashList [""].Add (regex);
}
public void ToStringTest()
{
string someExpression = "Some Expression *";
RegexFilter filter = new RegexFilter(new Regex(someExpression));
Assert.AreEqual(filter.ToString(), "Regex('" + someExpression + "', None)");
}
public IEnumerable<KspCraftObject> LookupCrafts (RegexFilter craftFilter)
{
var allCrafts = (kspObjTree is KspCraftObject) ? new[] { kspObjTree as KspCraftObject } : kspObjTree.Children <KspCraftObject> (recursive: true);
return craftFilter.Apply (allCrafts, craft => craft.Name);
}
