// Use this for initialization
private IEnumerator UpdateCollection(Transform panel, PatternCollection coll)
{
yield return(new WaitForEndOfFrame());
PatternCollectionManager.Instance.DrawCollectionOnPanel(
panel, coll, false);
}
public static PatternScanResult GetFirstWord(char[] TextBuffer,
PatternCollection Patterns, int StartPosition)
{
PatternScanResult Result;
Result.Index = 0;
Result.Token = "";
// for (int i=StartPosition;i<TextBuffer.Length;i++)
// {
//
// //-----------------------------------------------
// if (c[i]==PatternBuffer[0])
// {
// bool found=true;
// for (int j=0;j<Pattern.Length;j++)
// {
// if (c[i+j]!=p[j])
// {
// found=false;
// break;
// }
// }
// if (found)
// {
// Result.Index =i+StartPosition;
// Result.Token = Text.Substring(i+StartPosition,this.Pattern.Length);
// return Result;
// }
// }
// //-----------------------------------------------
// }
return Result;
}
static void Main(string[] args)
{
string dataPath = Reader.DefineFilePath("data.txt");
string configPath = Reader.DefineFilePath("config.txt");
PatternCollection patterns = Reader.ReadData(dataPath);
var configs = Reader.ReadConfigFile(configPath);
Parameters.InputNeurons = patterns.GetNeuronNumbers();
Parameters.HiddenNeurons = (int)configs["HiddenLayerNeurons"];
Parameters.OutputNeurons = patterns.GetNeuronNumbers();
Parameters.Random = new Random();
Parameters.Epochs = (int)configs["Epochs"];
Parameters.Step = configs["Step"];
Console.WriteLine("WITHOUT BIAS");
Network network = new Network();
network.Train(patterns);
network.Test(patterns);
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine("WITH BIAS");
network.AddBias();
network.Train(patterns);
network.Test(patterns);
Console.ReadKey();
}
/// <summary>
/// Removes tokens from this JSON token using a collection of patterns.
/// This naive algorithm marks all the affected leaves every time
/// a pattern is evaluated.
/// </summary>
public void Remove(JToken root, PatternCollection patterns)
{
var leaves = ((JContainer)root).DescendantsAndSelf().OfType <JValue>().ToArray();
var exclusionDictionary = leaves.ToDictionary(GetId, x => false);
foreach (var pattern in patterns)
{
foreach (var matched in root.SelectTokens(pattern.Expression))
{
foreach (var leaf in FindLeaves(matched))
{
exclusionDictionary[GetId(leaf)] = !pattern.IsNegated;
}
}
}
var toRemove = leaves.Where(x => exclusionDictionary[GetId(x)]);
var queue = new Queue <JToken>(toRemove);
while (queue.IsNotEmpty())
{
var toHandle = queue.Dequeue();
if (!toHandle.HasValues)
{
var parent = toHandle.RemoveFromParent();
if (parent != null)
{
queue.Enqueue(parent);
}
}
}
}
static void LoadStoredPatterns(ModelRepository repo)
{
// If there are no current stored devices config, simply add a new DeviceCollection.
if (!File.Exists(PATTERN_CONFIG_PATH))
{
repo["patterns"] = new PatternCollection();
return;
}
Stream read;
try
{
read = new FileStream(PATTERN_CONFIG_PATH, FileMode.Open);
}
catch (Exception ex)
{
throw new IOException("Unable to load stored patterns.", ex);
}
try
{
repo.Deserialize("patterns", typeof(iTunesAgent.Domain.PatternCollection), read);
}
finally
{
if (read != null)
{
read.Close();
}
}
}
public static PatternScanResult GetFirstWord(char[] TextBuffer, PatternCollection Patterns, int StartPosition)
{
PatternScanResult Result;
Result.Index = 0;
Result.Token = "";
// for (int i=StartPosition;i<TextBuffer.Length;i++)
// {
//
// //-----------------------------------------------
// if (c[i]==PatternBuffer[0])
// {
// bool found=true;
// for (int j=0;j<Pattern.Length;j++)
// {
// if (c[i+j]!=p[j])
// {
// found=false;
// break;
// }
// }
// if (found)
// {
// Result.Index =i+StartPosition;
// Result.Token = Text.Substring(i+StartPosition,this.Pattern.Length);
// return Result;
// }
// }
// //-----------------------------------------------
// }
return(Result);
}
public void DataProviderTesting()
{
byte[][] images = new byte[][]
{
new byte[] { 0, 1, 2, 3, 4, 5 },
new byte[] { 6, 7, 8, 9, 0, 1 }
};
byte[] labels = new byte[] { 0, 1 };
IImageReader imageReader = Mock.Of <IImageReader>(e => e.Height == 2 &&
e.Width == 3 &&
e.Data == images);
ILabelReader labelReader = Mock.Of <ILabelReader>(e => e.Data == labels);
DataProvider provider = new DataProvider(imageReader, labelReader);
PatternCollection result = provider.Load();
Assert.AreEqual(2, result.Count);
Assert.AreEqual(2, result.Height);
Assert.AreEqual(3, result.Width);
CollectionAssert.AreEqual(images[0], result[0].Image);
Assert.AreEqual(labels[0], result[0].Label);
CollectionAssert.AreEqual(images[1], result[1].Image);
Assert.AreEqual(labels[1], result[1].Label);
}
protected AbstractDateParser(string culture, string name)
{
Culture = culture;
Name = name;
Now = new PatternCollection();
Today = new PatternCollection();
Yesterday = new PatternCollection();
Tomorrow = new PatternCollection();
YearsAgo = new PatternCollection();
MonthsAgo = new PatternCollection();
WeeksAgo = new PatternCollection();
DaysAgo = new PatternCollection();
HoursAgo = new PatternCollection();
MinutesAgo = new PatternCollection();
SecondsAgo = new PatternCollection();
YearsFromNow = new PatternCollection();
MonthsFromNow = new PatternCollection();
WeeksFromNow = new PatternCollection();
DaysFromNow = new PatternCollection();
HoursFromNow = new PatternCollection();
MinutesFromNow = new PatternCollection();
SecondsFromNow = new PatternCollection();
Custom = new List<Func<string, DateTime?>>();
}
public PatternCollection Load()
{
LoadFromReaders();
PatternCollection collection = LoadToCollection();
return(collection);
}
void tmrInterval_Tick(object sender, EventArgs e)
{
tmrInterval.Stop();
SyntaxBoxControl syn = (tabDocs.SelectedTab.Controls[0] as SyntaxBoxControl);
if (syn == null)
{
return;
}
syn.AutoListVisible = false;
bool matches = false;
syn.AutoListClear();
Word w = syn.Document.GetWordFromPos(syn.Caret.Position);
if (w == null)
{
return;
}
string txt = w.Text, word = "";
if (!String.IsNullOrEmpty(txt) && txt.Length > 2)
{
syn.AutoListBeginLoad();
word = txt.Substring(0, 3);
PatternCollection pc = (syntaxDefinition.SpanDefinitions[0].LookupTable[word] as PatternCollection);
if (pc == null)
{
syn.AutoListEndLoad();
return;
}
foreach (Pattern p in pc)
{
if (p.StringPattern.Length >= txt.Length && p.StringPattern.Substring(0, txt.Length) == txt)
{
syn.AutoListAdd(p.StringPattern, 0);
matches = true;
}
}
syn.AutoListEndLoad();
if (matches)
{
syn.AutoListVisible = true;
syn.InfoTipVisible = false;
}
}
else if (txt.Trim() == "")
{
syn.InfoTipVisible = false;
}
}
public PatternSet(string name = "Patterns")
{
Name = name;
Allowed = true;
Highlights = new PatternCollection <Highlight>("Highlighting Patterns");
Filters = new PatternCollection <Filter> ("Filter Patterns");
Transforms = new PatternCollection <Transform>("Transform Patterns");
Actions = new PatternCollection <ClkAction>("Action Patterns");
}
public void CreateBoard(PatternCollection p)
{
var newBoard = new Board();
newBoard.coll = new PatternCollection();
newBoard.coll.Set(p);
Boards.Add(newBoard);
currentBoardID = Boards.Count - 1;
}
public void Set(PatternCollection p)
{
patterns.Clear();
foreach (var kvs in p.patterns)
{
var newPattern = new PatternItemInCollection();
newPattern.Set(kvs.Value);
patterns.Add(kvs.Key, newPattern);
}
}
public CldrData Build(string directory, PatternCollection patterns)
{
var cldrTreeBuilder = new CldrTreeBuilder();
var pageUpVersion = (string)null;
var done = 0;
foreach (var path in this.fileFinder.FindFiles(directory))
{
var json = File.ReadAllText(path);
var token = JObject.Parse(json);
var wasMatched = false;
foreach (var parser in this.jsonParsers)
{
if (!parser.IsValid(token))
{
continue;
}
var metadata = parser.ExtractMetadata(token);
parser.RemoveMetadata(token);
this.cldrVersionConsistencyAssurer.AssureVersionIsConsistent(metadata?.CldrVersion, path);
this.pageUpVersionConsistencyAssurer.AssureVersionIsConsistent(metadata?.PageUpVersion, path);
pageUpVersion = metadata?.PageUpVersion ?? pageUpVersion;
token.Subset(patterns);
var toAdd = parser.PrepareForMerging(metadata?.CldrLocale, token);
cldrTreeBuilder.Add(toAdd);
wasMatched = true;
}
if (!wasMatched)
{
// react depending on the options (-ignore, -warning, -error)
}
done++;
if (done % 100 == 0)
{
Console.WriteLine($"{done} files processed");
}
}
if (done % 100 != 0)
{
Console.WriteLine($"{done} files processed");
}
return(new CldrData
{
Tree = cldrTreeBuilder.Tree,
PageUpVersion = pageUpVersion
});
}
public void Test(PatternCollection p)
{
foreach (var item in p.Patterns)
{
CountOutputValues(item.Values);
item.ShowValues();
HiddenLayer.PrintNeuronValues();
OutputLayer.PrintNeuronValues();
Console.WriteLine("");
}
}
public void Train(PatternCollection patterns)
{
for (int i = 0; i < Parameters.Epochs; i++)
{
foreach (var pattern in patterns.Patterns)
{
CountOutputValues(pattern.Values);
ChangeAllWeights(pattern.Expected);
}
}
}
/// <summary>
/// Removes tokens from this JSON token using a collection of patterns.
/// </summary>
public static void Subset(this JToken root, PatternCollection patterns)
{
var decisions = new DecisionDictionary();
foreach (var pattern in patterns)
{
var matchedTokens = root.SelectTokens(pattern.Expression);
var toExclude = !pattern.IsNegated;
decisions.AddOrUpdateFor(matchedTokens, toExclude);
}
Subset(root, decisions.GetFor(root), decisions);
}
private PatternCollection LoadToCollection()
{
PatternCollection collection = new PatternCollection();
collection.Height = imageReader.Height;
collection.Width = imageReader.Width;
for (int i = 0; i < imageReader.Data.Length; i++)
{
Pattern pattern = new Pattern(imageReader.Data[i], labelReader.Data[i]);
collection.Add(pattern);
}
return(collection);
}
public void DrawCollectionOnBoard(Transform panel, PatternCollection collection, bool editable)
{
while (panel.childCount > 0)
{
Destroy(panel.GetChild(0).gameObject);
}
foreach (var kv in collection.patterns)
{
print(kv.Value.localPos);
print(kv.Value.originSize);
print(((RectTransform)panel).rect.size);
var xRatio = ((RectTransform)panel).rect.size.x / kv.Value.originSize.x;
var yRatio = ((RectTransform)panel).rect.size.y / kv.Value.originSize.y;
var newPattern = Instantiate(PatternCollectionManager.Instance.PatternPrefab);// kv.Value
//newPattern.transform.SetParent(panel, true);
var posOnPanel = new Vector3(
xRatio * kv.Value.localPos.x,
yRatio * kv.Value.localPos.y,
kv.Value.localPos.z);
print("Pattern Creation~~~~~~");
print(kv.Value.localPos);
print(posOnPanel);
//print(Camera.main.WorldToViewportPoint(panel.position));
newPattern.transform.position =
Camera.main.ViewportToWorldPoint(
posOnPanel +
Camera.main.WorldToViewportPoint(panel.position));
newPattern.GetComponent <PatternItemInCollection>().Set(kv.Value);
print(newPattern.transform.position);
newPattern.SetActive(true);
newPattern.GetComponent <Image>().sprite =
PatternCollectionManager.Instance.Patterns[kv.Value.PatternId].DisplayImage;
var rt = newPattern.GetComponent <RectTransform>();
rt.sizeDelta = new Vector2(
rt.sizeDelta.x * xRatio,
rt.sizeDelta.y * yRatio);
print("size:" + rt.sizeDelta);
newPattern.GetComponent <PatternItemInCollection>().IsEditing = editable;
}
}
public void TestSerializePatternCollection()
{
PatternCollection collection = new PatternCollection();
Pattern pattern = Pattern.Instance("itunes", "iTunes", "%MACRO1%\\%MACRO2%");
pattern.Compilationformat = "Compilation\\%MACRO3%";
pattern.Description = "Pattern descripiton";
collection.Patterns.Add(pattern);
XmlSerializer serializer = new XmlSerializer(collection.GetType());
FileStream stream = null;
try
{
stream = new FileStream("patterncollection.xml", FileMode.Create);
serializer.Serialize(stream, collection);
}
finally
{
if (stream != null)
stream.Close();
}
try
{
stream = new FileStream("patterncollection.xml", FileMode.Open);
PatternCollection deserializedCollection = (PatternCollection)
serializer.Deserialize(stream);
Assert.NotNull(deserializedCollection);
Assert.AreEqual(1, deserializedCollection.Patterns.Count);
Assert.AreEqual(pattern.Id, deserializedCollection.Patterns[0].Id);
Assert.AreEqual(pattern.Name, deserializedCollection.Patterns[0].Name);
Assert.AreEqual(pattern.Format, deserializedCollection.Patterns[0].Format);
Assert.AreEqual(pattern.Compilationformat, deserializedCollection.Patterns[0].Compilationformat);
Assert.AreEqual(pattern.Description, deserializedCollection.Patterns[0].Description);
}
finally
{
if (stream != null)
stream.Close();
}
File.Delete("patterncollection.xml");
}
public static void LoadPatterns(string filePath)
{
Patterns = new PatternCollection();
try
{
using (Stream fileStream = new FileStream(filePath, FileMode.Open))
{
StreamReader reader = new StreamReader(fileStream);
var xml = reader.ReadToEnd();
Patterns.BuildFromXml(xml);
}
}
catch (FileNotFoundException)
{
//TODO: handle the exception
}
}
public CldrData Build(string directory, PatternCollection patterns)
{
var cldrTreeBuilder = new CldrTreeBuilder();
var done = 0;
foreach (var path in this.fileFinder.FindFiles(directory))
{
var json = File.ReadAllText(path);
var token = JObject.Parse(json);
var wasMatched = false;
foreach (var parser in this.jsonParsers)
{
if (!parser.IsValid(token))
continue;
var metadata = parser.ExtractMetadata(token);
parser.RemoveMetadata(token);
this.versionConsistencyAssurer.AssureVersionIsConsistent(metadata?.CldrVersion, path);
token.Subset(patterns);
var toAdd = parser.PrepareForMerging(metadata?.CldrLocale, token);
cldrTreeBuilder.Add(toAdd);
wasMatched = true;
}
if (!wasMatched)
{
// react depending on the options (-ignore, -warning, -error)
}
done++;
if (done % 100 == 0)
Console.WriteLine($"{done} files processed");
}
if (done % 100 != 0)
Console.WriteLine($"{done} files processed");
return new CldrData
{
Tree = cldrTreeBuilder.Tree
};
}
public void HandWrittenTests(string original, string expected, string[] patterns)
{
// Arrange
var originalJson = JToken.Parse(original);
var expectedJson = JToken.Parse(expected);
var patternCollection = PatternCollection.Parse(patterns);
Console.WriteLine($"PATTERNS:\n{patterns.MergeLines()}\n");
Console.WriteLine($"ORIGINAL:\n{originalJson}\n");
Console.WriteLine($"EXPECTED:\n{expectedJson}\n");
// Act
originalJson.Subset(patternCollection);
// Assert
Console.WriteLine($"WAS:\n{originalJson}\n");
Assert.That(JToken.DeepEquals(expectedJson, originalJson));
}
public void MainModelLoadData()
{
byte[][] images = new byte[][]
{
new byte[] { 0, 1, 2, 3, 4, 5 },
new byte[] { 9, 8, 7, 6, 5, 4 }
};
PatternCollection patterns1 = new PatternCollection();
patterns1.Height = 2;
patterns1.Width = 3;
patterns1.Add(new Pattern(images[0], 0));
patterns1.Add(new Pattern(images[1], 1));
PatternCollection patterns2 = new PatternCollection();
patterns2.Height = 2;
patterns2.Width = 3;
patterns2.Add(new Pattern(images[0], 0));
IDataProvider dataProvider1 = Mock.Of <IDataProvider>(e => e.Load() == patterns1);
IDataProvider dataProvider2 = Mock.Of <IDataProvider>(e => e.Load() == patterns2);
MainModel model = new MainModel(new[] { dataProvider1, dataProvider2 });
Assert.IsNotNull(model.Collections);
Assert.AreEqual(2, model.Collections.Length);
Assert.AreEqual(2, model.Collections[0].Count);
CollectionAssert.AreEqual(images[0], model.Collections[0][0].Image);
Assert.AreEqual(0, model.Collections[0][0].Label);
CollectionAssert.AreEqual(images[1], model.Collections[0][1].Image);
Assert.AreEqual(1, model.Collections[0][1].Label);
Assert.AreEqual(1, model.Collections[1].Count);
CollectionAssert.AreEqual(images[0], model.Collections[0][0].Image);
Assert.AreEqual(0, model.Collections[0][0].Label);
Assert.AreEqual(-1, model.ActiveCollectionIndex);
Assert.IsNull(model.ActiveCollection);
model.ActiveCollectionIndex = 0;
Assert.AreEqual(2, model.ActiveCollection.Count);
}
public void LoadPatterns(PatternCollection patternCollection)
{
Patterns = patternCollection;
//This should be a property
int imageSize = 40;
int max, ratio;
Bitmap bitmap;
Graphics graphics;
foreach (Pattern pattern in Patterns)
{
max = 0;
foreach (Cell cell in pattern.Cells)
{
if (cell.Location.X > max) max = cell.Location.X;
if (cell.Location.Y > max) max = cell.Location.Y;
}
max++;
ratio = imageSize / max;
bitmap = new Bitmap(imageSize, imageSize);
graphics = Graphics.FromImage(bitmap);
foreach (Cell cell in pattern.Cells)
{
graphics.FillRectangle(Brushes.Black, cell.Location.X * ratio, cell.Location.Y * ratio, ratio, ratio);
}
graphics.DrawImageUnscaled(bitmap, 0, 0);
patternsImages.Images.Add(bitmap);
}
patternsView.LargeImageList = patternsImages;
patternsView.LargeImageList.ImageSize = new Size(imageSize, imageSize);
patternsView.View = View.LargeIcon;
for (int i = 0; i < patternsImages.Images.Count; i++)
{
patternsView.Items.Add(Patterns[i].Name, i);
patternsView.Items[i].ToolTipText = Patterns[i].Description;
patternsView.Items[i].Tag = i;
}
}
/// <summary>
/// Generates a collection of patterns for the specified <see cref="JContainer"/>.
/// </summary>
public PatternCollection GeneratePatterns(JContainer root, int desiredCount, bool skipValues = true)
{
var descendants = root.DescendantsAndSelf().ToArray();
descendants.Shuffle(random);
if (skipValues)
{
descendants = descendants.Where(x => x is JObject || x is JArray).ToArray();
}
var patterns = descendants
.Select(x => x.Path)
.Where(x => !string.IsNullOrWhiteSpace(x))
.Take(desiredCount)
.Select(x => (random.NextBool() ? "!" : "") + x)
.Select(AddWildcards)
.ToArray();
return(PatternCollection.Parse(patterns));
}
/// <summary>
/// Removes tokens from this JSON token using a collection of patterns.
/// This naive algorithm marks all the affected leaves every time
/// a pattern is evaluated.
/// </summary>
public void Remove(JToken root, PatternCollection patterns)
{
var leaves = ((JContainer) root).DescendantsAndSelf().OfType<JValue>().ToArray();
var exclusionDictionary = leaves.ToDictionary(GetId, x => false);
foreach (var pattern in patterns)
foreach (var matched in root.SelectTokens(pattern.Expression))
foreach (var leaf in FindLeaves(matched))
exclusionDictionary[GetId(leaf)] = !pattern.IsNegated;
var toRemove = leaves.Where(x => exclusionDictionary[GetId(x)]);
var queue = new Queue<JToken>(toRemove);
while (queue.IsNotEmpty())
{
var toHandle = queue.Dequeue();
if (!toHandle.HasValues)
{
var parent = toHandle.RemoveFromParent();
if (parent != null)
queue.Enqueue(parent);
}
}
}
public void BuildLookupTable()
{
tmpSimplePatterns.Sort(new PatternComparer());
foreach (Pattern.Pattern p in tmpSimplePatterns)
{
if (p.StringPattern.Length <= 2)
{
char c = p.StringPattern[0];
if (!p.Parent.CaseSensitive)
{
char c1 = char.ToLowerInvariant(c);
if (LookupTable[c1] == null)
{
LookupTable[c1] = new PatternCollection();
}
var patterns = LookupTable[c1] as PatternCollection;
if (patterns != null)
{
if (!patterns.Contains(p))
{
patterns.Add(p);
}
}
char c2 = char.ToUpper(c);
if (LookupTable[c2] == null)
{
LookupTable[c2] = new PatternCollection();
}
patterns = LookupTable[c2] as PatternCollection;
if (patterns != null)
{
if (!patterns.Contains(p))
{
patterns.Add(p);
}
}
}
else
{
if (LookupTable[c] == null)
{
LookupTable[c] = new PatternCollection();
}
var patterns = LookupTable[c] as PatternCollection;
if (patterns != null)
{
if (!patterns.Contains(p))
{
patterns.Add(p);
}
}
}
}
else
{
string c = p.StringPattern.Substring(0, 3).ToLowerInvariant();
if (LookupTable[c] == null)
{
LookupTable[c] = new PatternCollection();
}
var patterns = LookupTable[c] as PatternCollection;
if (patterns != null)
{
if (!patterns.Contains(p))
{
patterns.Add(p);
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="Pattern"></param>
/// <returns></returns>
public Pattern Add(Pattern Pattern)
{
if (Parent != null && Parent.Parent != null && Parent.Parent.Parent != null)
{
Pattern.Separators = Parent.Parent.Parent.Separators;
Parent.Parent.Parent.ChangeVersion();
}
if (!Pattern.IsComplex && !Pattern.ContainsSeparator)
{
//store pattern in lookuptable if it is a simple pattern
string s;
if (Pattern.StringPattern.Length >= 2)
{
s = Pattern.StringPattern.Substring(0, 2);
}
else
{
s = Pattern.StringPattern.Substring(0, 1) + " ";
}
s = s.ToLowerInvariant();
if (Pattern.StringPattern.Length == 1)
{
SimplePatterns1Char[Pattern.StringPattern] = Pattern;
}
else
{
if (SimplePatterns2Char[s] == null)
{
SimplePatterns2Char[s] = new PatternCollection();
}
var ar = (PatternCollection)SimplePatterns2Char[s];
ar.Add(Pattern);
}
if (CaseSensitive)
{
SimplePatterns[Pattern.LowerStringPattern] = Pattern;
}
else
{
SimplePatterns[Pattern.StringPattern] = Pattern;
}
}
else
{
ComplexPatterns.Add(Pattern);
}
patterns.Add(Pattern);
if (Pattern.Parent == null)
{
Pattern.Parent = this;
}
else
{
throw (new Exception("Pattern already assigned to another PatternList"));
}
return(Pattern);
}
private bool Equals(PatternCollection other)
{
return(base.Equals(other) && _useRegularExpressions == other._useRegularExpressions);
}
/// <summary>
/// Initializes a new instance of the <see cref="FilterSet"/> class.
/// </summary>
public FilterSet()
{
Exclude = new PatternCollection();
}
/// <summary>
/// Removes tokens from this JSON token using a collection of patterns.
/// This naive algorithm marks all the affected leaves every time
/// a pattern is evaluated.
/// </summary>
public static void NaiveRemove(this JToken root, PatternCollection patterns)
{
var remover = new NaiveTokenRemover();
remover.Remove(root, patterns);
}
private ScanResult_Word GetNextComplexWord(String Text, Segment CurrentSegment, int StartPositon)
{
if (StartPositon >= Text.Length)
{
return(new ScanResult_Word());
}
ScanResult_Word Result = new ScanResult_Word();
int CurrentPosition = 0;
//look for keywords
PatternListList keywordsList = CurrentSegment.BlockType.KeywordsList;
PatternList List = null;
for (int i = 0; i < keywordsList.Count; i++)
{
List = keywordsList[i];
PatternCollection complexPatterns = List.ComplexPatterns;
Pattern Word = null;
for (int j = 0; j < complexPatterns.Count; j++)
{
Word = complexPatterns[j];
PatternScanResult psr = Word.IndexIn(Text, StartPositon, false, Separators);
CurrentPosition = psr.Index;
if ((CurrentPosition < Result.Position || Result.HasContent == false) && psr.Token != "")
{
Result.HasContent = true;
Result.Position = CurrentPosition;
Result.Token = psr.Token;
Result.Pattern = Word;
Result.ParentList = List;
if (List.NormalizeCase)
{
if (!Word.IsComplex)
{
Result.Token = Word.StringPattern;
}
}
}
}
}
//look for operators
PatternListList pattList = CurrentSegment.BlockType.OperatorsList;
PatternList patternList = null;
for (int i = 0; i < pattList.Count; i++)
{
patternList = pattList[i];
PatternCollection complexPatterns = patternList.ComplexPatterns;
for (int j = 0; j < complexPatterns.Count; j++)
{
Pattern Word = complexPatterns[j];
PatternScanResult psr = Word.IndexIn(Text, StartPositon, false, Separators);
CurrentPosition = psr.Index;
if ((CurrentPosition < Result.Position || Result.HasContent == false) && psr.Token != "")
{
Result.HasContent = true;
Result.Position = CurrentPosition;
Result.Token = psr.Token;
Result.Pattern = Word;
Result.ParentList = patternList;
if (patternList.NormalizeCase)
{
if (!Word.IsComplex)
{
Result.Token = Word.StringPattern;
}
}
}
}
}
if (Result.HasContent)
{
return(Result);
}
else
{
return(new ScanResult_Word());
}
}
private ScanResult_Word GetNextWord(string Text, Segment CurrentSegment, int StartPos, ref bool HasComplex)
{
BlockType block = CurrentSegment.BlockType;
#region ComplexFind
int BestComplexPos = -1;
Pattern BestComplexPattern = null;
string BestComplexToken = "";
ScanResult_Word complexword = new ScanResult_Word();
if (HasComplex)
{
foreach (Pattern pattern in block.ComplexPatterns)
{
PatternScanResult scanres = pattern.IndexIn(Text, StartPos, pattern.Parent.CaseSensitive, this.Separators);
if (scanres.Token != "")
{
if (scanres.Index < BestComplexPos || BestComplexPos == -1)
{
BestComplexPos = scanres.Index;
BestComplexPattern = pattern;
BestComplexToken = scanres.Token;
}
}
}
if (BestComplexPattern != null)
{
complexword.HasContent = true;
complexword.ParentList = BestComplexPattern.Parent;
complexword.Pattern = BestComplexPattern;
complexword.Position = BestComplexPos;
complexword.Token = BestComplexToken;
HasComplex = true;
}
else
{
HasComplex = false;
}
}
#endregion
#region SimpleFind
ScanResult_Word simpleword = new ScanResult_Word();
for (int i = StartPos; i < Text.Length; i++)
{
//bailout if we found a complex pattern before this char pos
if (i > complexword.Position && complexword.HasContent)
{
break;
}
#region 3+ char pattern
if (i <= Text.Length - 3)
{
string key = Text.Substring(i, 3).ToLower();
PatternCollection patterns2 = (PatternCollection)block.LookupTable[key];
//ok , there are patterns that start with this char
if (patterns2 != null)
{
foreach (Pattern pattern in patterns2)
{
int len = pattern.StringPattern.Length;
if (i + len > Text.Length)
{
continue;
}
char lastpatternchar = char.ToLower(pattern.StringPattern[len - 1]);
char lasttextchar = char.ToLower(Text[i + len - 1]);
#region Case Insensitive
if (lastpatternchar == lasttextchar)
{
if (!pattern.IsKeyword || (pattern.IsKeyword && pattern.HasSeparators(Text, i)))
{
if (!pattern.Parent.CaseSensitive)
{
string s = Text.Substring(i, len).ToLower();
if (s == pattern.StringPattern.ToLower())
{
simpleword.HasContent = true;
simpleword.ParentList = pattern.Parent;
simpleword.Pattern = pattern;
simpleword.Position = i;
if (pattern.Parent.NormalizeCase)
{
simpleword.Token = pattern.StringPattern;
}
else
{
simpleword.Token = Text.Substring(i, len);
}
break;
}
}
else
{
string s = Text.Substring(i, len);
if (s == pattern.StringPattern)
{
simpleword.HasContent = true;
simpleword.ParentList = pattern.Parent;
simpleword.Pattern = pattern;
simpleword.Position = i;
simpleword.Token = pattern.StringPattern;
break;
}
}
}
}
}
#endregion
}
}
#endregion
if (simpleword.HasContent)
{
break;
}
#region single char pattern
char c = Text[i];
PatternCollection patterns = (PatternCollection)block.LookupTable[c];
if (patterns != null)
{
//ok , there are patterns that start with this char
foreach (Pattern pattern in patterns)
{
int len = pattern.StringPattern.Length;
if (i + len > Text.Length)
{
continue;
}
char lastpatternchar = pattern.StringPattern[len - 1];
char lasttextchar = Text[i + len - 1];
if (!pattern.Parent.CaseSensitive)
{
#region Case Insensitive
if (char.ToLower(lastpatternchar) == char.ToLower(lasttextchar))
{
if (!pattern.IsKeyword || (pattern.IsKeyword && pattern.HasSeparators(Text, i)))
{
string s = Text.Substring(i, len).ToLower();
if (s == pattern.StringPattern.ToLower())
{
simpleword.HasContent = true;
simpleword.ParentList = pattern.Parent;
simpleword.Pattern = pattern;
simpleword.Position = i;
simpleword.Token = Text.Substring(i, len);
break;
}
}
}
#endregion
}
else
{
#region Case Sensitive
if (lastpatternchar == lasttextchar)
{
if (!pattern.IsKeyword || (pattern.IsKeyword && pattern.HasSeparators(Text, i)))
{
string s = Text.Substring(i, len);
if (s == pattern.StringPattern)
{
simpleword.HasContent = true;
simpleword.ParentList = pattern.Parent;
simpleword.Pattern = pattern;
simpleword.Position = i;
simpleword.Token = pattern.StringPattern;
break;
}
}
}
#endregion
}
}
if (simpleword.HasContent)
{
break;
}
}
#endregion
}
#endregion
if (complexword.HasContent && simpleword.HasContent)
{
if (simpleword.Position == complexword.Position)
{
if (simpleword.Token.Length > complexword.Token.Length)
{
return(simpleword);
}
else
{
return(complexword);
}
}
if (simpleword.Position < complexword.Position)
{
return(simpleword);
}
if (simpleword.Position > complexword.Position)
{
return(complexword);
}
}
if (simpleword.HasContent)
{
return(simpleword);
}
if (complexword.HasContent)
{
return(complexword);
}
return(new ScanResult_Word());
}
public WindowMain()
{
InitializeComponent();
(Top, Left) = Preferences.Default.LastMainWindowPosition;
(Height, Width) = Preferences.Default.MainWindowSize;
#region Menu Population
Pref.Command = new RelayCommand(o => {
var preferences = new WindowPreferences {
Owner = this
};
preferences.ShowDialog();
Topmost = Preferences.Default.MainWindowTopmost;
appIcon.Visible = Preferences.Default.AlwaysShowTrayIcon;
});
AddRuleItem.Command = FileNew.Command = new RelayCommand(true, o => {
var editRule = new WindowEditRule(new MyTask())
{
Owner = this
};
editRule.ShowDialog();
Tasks.Add(WindowEditRule.Task);
});
AddExtItem.Command = AddExtension.Command = new RelayCommand(o => ItemsGrid.SelectedIndex != -1, o => {
var addExtensionDialog = new WindowAddPattern {
Owner = this
};
addExtensionDialog.ShowDialog();
if (!string.IsNullOrWhiteSpace(addExtensionDialog.NewExtension))
{
PatternCollection.Add(addExtensionDialog.NewExtension);
}
});
EditRuleItem.Command = EditRule.Command = new RelayCommand(o => ItemsGrid.SelectedIndex != -1, o => {
var editRule = new WindowEditRule(Tasks[ItemsGrid.SelectedIndex])
{
Owner = this
};
editRule.ShowDialog();
if (!Tasks.Contains(WindowEditRule.Task))
{
Tasks.Add(WindowEditRule.Task);
}
});
EditExtItem.Command = EditExtension.Command = new RelayCommand(o => PatternList.SelectedIndex != -1 && ItemsGrid.SelectedIndex != -1, o => {
var addExtensionDialog = new WindowAddPattern(PatternCollection[PatternList.SelectedIndex].Clone() as string)
{
Owner = this
};
addExtensionDialog.ShowDialog();
if (!string.IsNullOrWhiteSpace(addExtensionDialog.NewExtension))
{
PatternCollection.RemoveAt(PatternList.SelectedIndex);
PatternCollection.Add(addExtensionDialog.NewExtension);
}
});
RemoveRuleItem.Command = RemoveRule.Command = new RelayCommand(o => ItemsGrid.SelectedIndex != -1, o => {
Tasks[ItemsGrid.SelectedIndex].IsMoving = false;
Tasks.RemoveAt(ItemsGrid.SelectedIndex);
});
RemoveExtItem.Command = RemoveExtension.Command = new RelayCommand(o => PatternList.SelectedIndex != -1 && ItemsGrid.SelectedIndex != -1, o => {
PatternCollection.RemoveAt(PatternList.SelectedIndex);
});
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="IncludeSet"/> class.
/// </summary>
public IncludeSet()
{
Include = new PatternCollection();
}
public TokenFragment(PatternCollection pattern)
{
Pattern = pattern;
}
public static void SavePatterns(PatternCollection patterns, string fileName)
{
throw new NotImplementedException();
}
/// <summary>
///
/// </summary>
/// <param name="Pattern"></param>
/// <returns></returns>
public Pattern Add(Pattern Pattern)
{
if (Parent != null && Parent.Parent != null &&
Parent.Parent.Parent != null)
{
Pattern.Separators = Parent.Parent.Parent.Separators;
Parent.Parent.Parent.ChangeVersion();
}
if (!Pattern.IsComplex && !Pattern.ContainsSeparator)
{
//store pattern in lookuptable if it is a simple pattern
string s;
if (Pattern.StringPattern.Length >= 2)
s = Pattern.StringPattern.Substring(0, 2);
else
s = Pattern.StringPattern.Substring(0, 1) + " ";
s = s.ToLowerInvariant();
if (Pattern.StringPattern.Length == 1)
{
SimplePatterns1Char[Pattern.StringPattern] = Pattern;
}
else
{
if (SimplePatterns2Char[s] == null)
SimplePatterns2Char[s] = new PatternCollection();
var ar = (PatternCollection) SimplePatterns2Char[s];
ar.Add(Pattern);
}
if (CaseSensitive)
SimplePatterns[Pattern.LowerStringPattern] = Pattern;
else
SimplePatterns[Pattern.StringPattern] = Pattern;
}
else
{
ComplexPatterns.Add(Pattern);
}
patterns.Add(Pattern);
if (Pattern.Parent == null)
Pattern.Parent = this;
else
{
throw (new Exception("Pattern already assigned to another PatternList"));
}
return Pattern;
}
/// <summary>
/// Removes tokens from this JSON token using a collection of patterns.
/// This naive algorithm marks all the affected leaves every time
/// a pattern is evaluated.
/// </summary>
public static void NaiveRemove(this JToken root, PatternCollection patterns)
{
var remover = new NaiveTokenRemover();
remover.Remove(root, patterns);
}
/// <summary>
/// Validates an XML document against the <see cref="SchemaDocument"/>.
/// </summary>
/// <param name="instance">
/// The <see cref="IXPathNavigable">XML document</see> to validate.
/// </param>
/// <param name="handler">A <see cref="SchematronValidationEventHandler"/> to receive errors.</param>
/// <remarks>
/// <b>Validate</b> validates the <paramref name="instance"/> against the <see cref="SchemaDocument"/>.
/// <para>
/// If an error is detected and
/// the <see cref="AssertionFailed"/> event is <b>null</b>, then a <see cref="SchematronValidationException"/>is <c>thrown</c>.
/// Otherwise, the <see cref="AssertionFailed"/> event is raised.
/// </para>
/// </remarks>
public void Validate(IXPathNavigable instance, SchematronValidationEventHandler handler = null)
{
if (instance == null)
throw new ArgumentNullException("instance");
if (schematron == null)
throw new InvalidOperationException("The schematron document is not specified.");
if (SchemaDocument.Patterns == null || SchemaDocument.Patterns.Count == 0)
throw new InvalidOperationException("The schematron document has no patterns.");
if (handler != null)
AssertionFailed += handler;
instanceNavigator = instance.CreateNavigator();
if (log.IsDebugEnabled)
log.Debug(string.Format("Validating '{0}'", instanceNavigator.BaseURI ?? "some XML document"));
// Bind to the query language.
if (!Schematron.Default.QueryLanguages.Providers.ContainsKey(schematron.QueryLanguage))
throw new InvalidOperationException(String.Format("'{0}' is an unknown query language.", schematron.QueryLanguage));
queryEngine = Schematron.Default.QueryLanguages.Providers[schematron.QueryLanguage];
queryContext = queryEngine.CreateMatchContext(schematron, instance);
// Apply the schema parameters.
if (schematron.HasParameters)
{
foreach (string name in schematron.Parameters)
{
queryEngine.Let(queryContext, name, schematron.Parameters[name]);
}
}
// Get the patterns to run.
PatternCollection activePatterns;
string phaseName = ValidationPhase;
if (phaseName == Phase.Default)
phaseName = schematron.DefaultPhase;
if (phaseName == Phase.All)
activePatterns = schematron.Patterns;
else
{
Phase phase = schematron.Phases[phaseName];
activePatterns = new PatternCollection();
foreach (ActivePattern activePattern in phase.ActivePatterns)
{
activePatterns.Add(schematron.Patterns[activePattern.Pattern]);
}
// Apply the phase parameters.
if (phase.HasParameters)
{
queryEngine.PushScope(queryContext);
foreach (string name in phase.Parameters)
{
queryEngine.Let(queryContext, name, phase.Parameters[name]);
}
}
}
// Apply the parameters specified for this validation.
if (HasParameters)
{
queryEngine.PushScope(queryContext);
foreach (string name in Parameters)
{
queryEngine.Let(queryContext, name, Parameters[name]);
}
}
if (log.IsDebugEnabled)
log.Debug(String.Format("Schema = '{0}', phase = '{1}'", schematron.Title.ToString(), phaseName));
if (Start != null)
Start(this, new SchematronValidationEventArgs(schematron, queryEngine, null, null, null, queryContext, instanceNavigator));
try
{
foreach (Pattern pattern in activePatterns)
{
if (log.IsDebugEnabled)
log.Debug(string.Format("Running pattern '{0}'", pattern.Title.ToString()));
if (ActivePattern != null)
ActivePattern(this, new SchematronValidationEventArgs(schematron, queryEngine, pattern, null, null, queryContext, instanceNavigator));
// Apply the parameters
queryEngine.PushScope(queryContext);
if (pattern.HasParameters)
{
foreach (string name in pattern.Parameters)
{
queryEngine.Let(queryContext, name, pattern.Parameters[name]);
}
}
// Run the pattern.
bool q = RunPattern(pattern);
queryEngine.PopScope(queryContext);
if (log.IsDebugEnabled)
log.Debug(String.Format("Pattern '{0}' {1}", pattern.Title.ToString(), q ? "succeeds" : "fails"));
}
}
finally
{
if (End != null)
End(this, new SchematronValidationEventArgs(schematron, queryEngine, null, null, null, queryContext, instanceNavigator));
}
}
