ContentCoding/ParseDictionary.cs at main · BUTTER-Tools/ContentCoding · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using PluginContracts;


namespace ContentCoding
{
    //partial class because we're splitting this bad boy up between files
    internal class DictParser
    {


        public DictionaryData ParseDict(DictionaryMetaObject DictionaryToParse)
        {


            DictionaryData DictData = DictionaryToParse.DictData;

            //  ____                   _       _         ____  _      _   ____        _           ___  _     _           _
            // |  _ \ ___  _ __  _   _| | __ _| |_ ___  |  _ \(_) ___| |_|  _ \  __ _| |_ __ _   / _ \| |__ (_) ___  ___| |_
            // | |_) / _ \| '_ \| | | | |/ _` | __/ _ \ | | | | |/ __| __| | | |/ _` | __/ _` | | | | | '_ \| |/ _ \/ __| __|
            // |  __/ (_) | |_) | |_| | | (_| | ||  __/ | |_| | | (__| |_| |_| | (_| | || (_| | | |_| | |_) | |  __/ (__| |_
            // |_|   \___/| .__/ \__,_|_|\__,_|\__\___| |____/|_|\___|\__|____/ \__,_|\__\__,_|  \___/|_.__// |\___|\___|\__|
            //            |_|                                                                             |__/


            //parse out the the dictionary file
            DictData.MaxWords = 0;

            //yeah, there's levels to this thing
            DictData.FullDictionary = new Dictionary<string, Dictionary<int, Dictionary<string, string[]>>>();

            DictData.FullDictionary.Add("Wildcards", new Dictionary<int, Dictionary<string, string[]>>());
            DictData.FullDictionary.Add("Standards", new Dictionary<int, Dictionary<string, string[]>>());

            DictData.WildCardArrays = new Dictionary<int, string[]>();
            DictData.PrecompiledWildcards = new Dictionary<string, Regex>();


            Dictionary<int, List<string>> WildCardLists = new Dictionary<int, List<string>>();

                string[] DicSplit = DictionaryToParse.DictionaryRawText.Split(new char[] { '%' }, 3, StringSplitOptions.None);

                string[] HeaderLines = DicSplit[1].Trim().Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
                string[] EntryLines = DicSplit[2].Trim().Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);

                DictData.NumCats = HeaderLines.Length;

                //now that we know the number of categories, we can fill out the arrays
                DictData.CatNames = new string[DictData.NumCats];
                DictData.CatValues = new string[DictData.NumCats];


                //Map Out the Categories
                for (int i = 0; i < DictData.NumCats; i++)
                {
                    string[] HeaderRow = HeaderLines[i].Trim().Split(new char[] { '\t' }, 2);

                    DictData.CatValues[i] = HeaderRow[0];
                    DictData.CatNames[i] = HeaderRow[1];
                }


                //Map out the dictionary entries
                for (int i = 0; i < EntryLines.Length; i++)
                {

                    string EntryLine = EntryLines[i].Trim();
                    while (EntryLine.Contains("  ")) EntryLine.Replace("  ", " ");

                    string[] EntryRow = EntryLine.Trim().Split(new char[] { '\t' }, StringSplitOptions.RemoveEmptyEntries);

                    if (EntryRow.Length > 1 && !String.IsNullOrWhiteSpace(EntryRow[0])) {

                        int Words_In_Entry = EntryRow[0].Split(' ').Length;
                        if (Words_In_Entry > DictData.MaxWords) DictData.MaxWords = Words_In_Entry;

                        if (EntryRow[0].Contains("*"))
                        {

                            if (DictData.FullDictionary["Wildcards"].ContainsKey(Words_In_Entry))
                            {
                                if (!DictData.FullDictionary["Wildcards"][Words_In_Entry].ContainsKey(EntryRow[0].ToLower()))
                                {
                                    DictData.FullDictionary["Wildcards"][Words_In_Entry].Add(EntryRow[0].ToLower(), EntryRow.Skip(1).ToArray());
                                    WildCardLists[Words_In_Entry].Add(EntryRow[0].ToLower());
                                    DictData.PrecompiledWildcards.Add(EntryRow[0].ToLower(), new Regex("^" + Regex.Escape(EntryRow[0].ToLower()).Replace("\\*", ".*") + "$", RegexOptions.Compiled));
                                }
                            }
                            else
                            {
                                DictData.FullDictionary["Wildcards"].Add(Words_In_Entry, new Dictionary<string, string[]> { { EntryRow[0].ToLower(), EntryRow.Skip(1).ToArray() } });
                                WildCardLists.Add(Words_In_Entry, new List<string>(new string[] { EntryRow[0].ToLower() }));
                                DictData.PrecompiledWildcards.Add(EntryRow[0].ToLower(), new Regex("^" + Regex.Escape(EntryRow[0].ToLower()).Replace("\\*", ".*") + "$", RegexOptions.Compiled));
                            }


                        }
                        else
                        {
                            if (DictData.FullDictionary["Standards"].ContainsKey(Words_In_Entry))
                            {
                                if (!DictData.FullDictionary["Standards"][Words_In_Entry].ContainsKey(EntryRow[0].ToLower()))
                                    DictData.FullDictionary["Standards"][Words_In_Entry].Add(EntryRow[0].ToLower(), EntryRow.Skip(1).ToArray());
                            }
                            else
                            {
                                DictData.FullDictionary["Standards"].Add(Words_In_Entry, new Dictionary<string, string[]> { { EntryRow[0].ToLower(), EntryRow.Skip(1).ToArray() } });
                            }
                        }
                    }
                }


            for (int i = DictData.MaxWords; i > 0; i--)
                {
                    if (WildCardLists.ContainsKey(i)) DictData.WildCardArrays.Add(i, WildCardLists[i].ToArray());
                }
                WildCardLists.Clear();
                DictData.DictionaryLoaded = true;

                //MessageBox.Show("Your dictionary has been successfully loaded.", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);

                return DictData;


        }


    }
}