Пример #1
0
		/// <summary>
		///     Copies the elements of an array at the end of this instance of 'AffixEntryCollection'.
		/// </summary>
		/// <param name='value'>
		///     An array of 'AffixEntry' objects to add to the collection.
		/// </param>
		public void AddRange(AffixEntry[] value) 
		{
			for (int Counter = 0; (Counter < value.Length); Counter = (Counter + 1)) 
			{
				this.Add(value[Counter]);
			}
		}
Пример #2
0
        /// <summary>
        ///     Removes the affix suffix rule entry for the word if valid
        /// </summary>
        /// <param name="word" type="string">
        ///     <para>
        ///         The word to be modified
        ///     </para>
        /// </param>
        /// <param name="entry" type="NetSpell.SpellChecker.Dictionary.Affix.AffixEntry">
        ///     <para>
        ///         The affix rule entry to use
        ///     </para>
        /// </param>
        /// <returns>
        ///     The word after affix removed.  Will be the same word if affix could not be removed.
        /// </returns>
        /// <remarks>
        ///		This method does not verify that the returned word is a valid word, only that the affix can be removed
        /// </remarks>
        public static string RemoveSuffix(string word, AffixEntry entry)
        {
            int tempLength = word.Length - entry.AddCharacters.Length;

            if ((tempLength > 0) &&
                (tempLength + entry.StripCharacters.Length >= entry.ConditionCount) &&
                (word.EndsWith(entry.AddCharacters)))
            {
                // word with out affix
                string tempWord = word.Substring(0, tempLength);
                // add back strip chars
                tempWord += entry.StripCharacters;
                // check that this is valid
                int passCount = 0;
                for (int i = 0; i < entry.ConditionCount; i++)
                {
                    int charCode = (int)tempWord[tempWord.Length - (entry.ConditionCount - i)];
                    if ((entry.Condition[charCode] & (1 << i)) == (1 << i))
                    {
                        passCount++;
                    }
                }
                if (passCount == entry.ConditionCount)
                {
                    return(tempWord);
                }
            }
            return(word);
        }
Пример #3
0
        /// <summary>
        ///     Generates the condition character array
        /// </summary>
        /// <param name="conditionText" type="string">
        ///     <para>
        ///         the text form of the conditions
        ///     </para>
        /// </param>
        /// <param name="entry" type="NetSpell.SpellChecker.Dictionary.Affix.AffixEntry">
        ///     <para>
        ///         The AffixEntry to add the condition array to
        ///     </para>
        /// </param>
        public static void EncodeConditions(string conditionText, AffixEntry entry)
        {
            // clear the conditions array
            for (int i=0; i < entry.Condition.Length; i++)
            {
                entry.Condition[i] = 0;
            }

            // if no condition just return
            if (conditionText == ".")
            {
                entry.ConditionCount = 0;
                return;
            }

            bool neg = false;  /* complement indicator */
            bool group = false;  /* group indicator */
            bool end = false;   /* end condition indicator */
            int num = 0;    /* number of conditions */

            char [] memberChars = new char[200];
            int numMember = 0;   /* number of member in group */

            foreach (char cond in conditionText)
            {
                // parse member group
                if (cond == '[')
                {
                    group = true;  // start a group
                }
                else if (cond == '^' && group)
                {
                    neg = true; // negative group
                }
                else if (cond == ']')
                {
                    end = true; // end of a group
                }
                else if (group)
                {
                    // add chars to group
                    memberChars[numMember] = cond;
                    numMember++;
                }
                else
                {
                    end = true;  // no group
                }

                // set condition
                if (end)
                {
                    if (group)
                    {
                        if (neg)
                        {
                            // turn all chars on
                            for (int j=0; j < entry.Condition.Length; j++)
                            {
                                entry.Condition[j] = entry.Condition[j] | (1 << num);
                            }
                            // turn off chars in member group
                            for (int j=0; j < numMember; j++)
                            {
                                int charCode = (int)memberChars[j];
                                entry.Condition[charCode] = entry.Condition[charCode] & ~(1 << num);
                            }
                        }
                        else
                        {
                            // turn on chars in member group
                            for (int j=0; j < numMember; j++)
                            {
                                int charCode = (int)memberChars[j];
                                entry.Condition[charCode] = entry.Condition[charCode] | (1 << num);
                            }
                        }
                        group = false;
                        neg = false;
                        numMember = 0;
                    } // if group
                    else
                    {
                        if (cond == '.')
                        {
                            // wild card character, turn all chars on
                            for (int j=0; j < entry.Condition.Length; j++)
                            {
                                entry.Condition[j] = entry.Condition[j] | (1 << num);
                            }
                        }
                        else
                        {
                            // turn on char
                            int charCode = (int)cond;
                            entry.Condition[charCode] = entry.Condition[charCode] | (1 << num);
                        }
                    } // not group

                    end = false;
                    num++;
                } // if end
            } // foreach char

            entry.ConditionCount = num;
            return;
        }
 /// <summary>
 ///     Adds a 'AffixEntry' item with the specified value to the 'AffixEntryCollection'
 /// </summary>
 /// <param name='value'>
 ///     The 'AffixEntry' to add.
 /// </param>
 /// <returns>
 ///     The index at which the new element was inserted.
 /// </returns>
 public int Add(AffixEntry value)
 {
     return List.Add(value);
 }
 /// <summary>
 ///     Initializes a new instance of 'AffixEntryCollection' with an array of 'AffixEntry' objects.
 /// </summary>
 /// <param name='value'>
 ///     An array of 'AffixEntry' objects with which to initialize the collection
 /// </param>
 public AffixEntryCollection(AffixEntry[] value)
 {
     this.AddRange(value);
 }
 /// <summary>
 ///     Removes a specific item from the 'AffixEntryCollection'.
 /// </summary>
 /// <param name='value'>
 ///     The item to remove from the 'AffixEntryCollection'.
 /// </param>
 public void Remove(AffixEntry value)
 {
     List.Remove(value);
 }
 /// <summary>
 ///     Inserts an existing 'AffixEntry' into the collection at the specified index.
 /// </summary>
 /// <param name='index'>
 ///     The zero-based index where the new item should be inserted.
 /// </param>
 /// <param name='value'>
 ///     The item to insert.
 /// </param>
 public void Insert(int index, AffixEntry value)
 {
     List.Insert(index, value);
 }
 /// <summary>
 ///     Returns the index of a 'AffixEntry' object in the collection.
 /// </summary>
 /// <param name='value'>
 ///     The 'AffixEntry' object whose index will be retrieved.
 /// </param>
 /// <returns>
 ///     If found, the index of the value; otherwise, -1.
 /// </returns>
 public int IndexOf(AffixEntry value)
 {
     return List.IndexOf(value);
 }
Пример #9
0
 /// <summary>
 ///     Returns the index of a 'AffixEntry' object in the collection.
 /// </summary>
 /// <param name='value'>
 ///     The 'AffixEntry' object whose index will be retrieved.
 /// </param>
 /// <returns>
 ///     If found, the index of the value; otherwise, -1.
 /// </returns>
 public int IndexOf(AffixEntry value)
 {
     return(List.IndexOf(value));
 }
 /// <summary>
 ///     Gets a value indicating whether the 'AffixEntryCollection' contains the specified value.
 /// </summary>
 /// <param name='value'>
 ///     The item to locate.
 /// </param>
 /// <returns>
 ///     True if the item exists in the collection; false otherwise.
 /// </returns>
 public bool Contains(AffixEntry value)
 {
     return List.Contains(value);
 }
Пример #11
0
        /// <summary>
        ///     Generates the condition character array
        /// </summary>
        /// <param name="conditionText" type="string">
        ///     <para>
        ///         the text form of the conditions
        ///     </para>
        /// </param>
        /// <param name="entry" type="NetSpell.SpellChecker.Dictionary.Affix.AffixEntry">
        ///     <para>
        ///         The AffixEntry to add the condition array to
        ///     </para>
        /// </param>
        public static void EncodeConditions(string conditionText, AffixEntry entry)
        {
            // clear the conditions array
            for (int i = 0; i < entry.Condition.Length; i++)
            {
                entry.Condition[i] = 0;
            }

            // if no condition just return
            if (conditionText == ".")
            {
                entry.ConditionCount = 0;
                return;
            }

            bool neg   = false;         /* complement indicator */
            bool group = false;         /* group indicator */
            bool end   = false;         /* end condition indicator */
            int  num   = 0;             /* number of conditions */

            char [] memberChars = new char[200];
            int     numMember   = 0;         /* number of member in group */

            foreach (char cond in conditionText)
            {
                // parse member group
                if (cond == '[')
                {
                    group = true;                      // start a group
                }
                else if (cond == '^' && group)
                {
                    neg = true;                     // negative group
                }
                else if (cond == ']')
                {
                    end = true;                     // end of a group
                }
                else if (group)
                {
                    // add chars to group
                    memberChars[numMember] = cond;
                    numMember++;
                }
                else
                {
                    end = true;                      // no group
                }

                // set condition
                if (end)
                {
                    if (group)
                    {
                        if (neg)
                        {
                            // turn all chars on
                            for (int j = 0; j < entry.Condition.Length; j++)
                            {
                                entry.Condition[j] = entry.Condition[j] | (1 << num);
                            }
                            // turn off chars in member group
                            for (int j = 0; j < numMember; j++)
                            {
                                int charCode = (int)memberChars[j];
                                entry.Condition[charCode] = entry.Condition[charCode] & ~(1 << num);
                            }
                        }
                        else
                        {
                            // turn on chars in member group
                            for (int j = 0; j < numMember; j++)
                            {
                                int charCode = (int)memberChars[j];
                                entry.Condition[charCode] = entry.Condition[charCode] | (1 << num);
                            }
                        }
                        group     = false;
                        neg       = false;
                        numMember = 0;
                    }                     // if group
                    else
                    {
                        if (cond == '.')
                        {
                            // wild card character, turn all chars on
                            for (int j = 0; j < entry.Condition.Length; j++)
                            {
                                entry.Condition[j] = entry.Condition[j] | (1 << num);
                            }
                        }
                        else
                        {
                            // turn on char
                            int charCode = (int)cond;
                            entry.Condition[charCode] = entry.Condition[charCode] | (1 << num);
                        }
                    }                     // not group

                    end = false;
                    num++;
                }         // if end
            }             // foreach char

            entry.ConditionCount = num;
            return;
        }
Пример #12
0
 /// <summary>
 ///     Adds a 'AffixEntry' item with the specified value to the 'AffixEntryCollection'
 /// </summary>
 /// <param name='value'>
 ///     The 'AffixEntry' to add.
 /// </param>
 /// <returns>
 ///     The index at which the new element was inserted.
 /// </returns>
 public int Add(AffixEntry value)
 {
     return(List.Add(value));
 }
Пример #13
0
 /// <summary>
 ///     Removes a specific item from the 'AffixEntryCollection'.
 /// </summary>
 /// <param name='value'>
 ///     The item to remove from the 'AffixEntryCollection'.
 /// </param>
 public void Remove(AffixEntry value)
 {
     List.Remove(value);
 }
Пример #14
0
 /// <summary>
 ///     Inserts an existing 'AffixEntry' into the collection at the specified index.
 /// </summary>
 /// <param name='index'>
 ///     The zero-based index where the new item should be inserted.
 /// </param>
 /// <param name='value'>
 ///     The item to insert.
 /// </param>
 public void Insert(int index, AffixEntry value)
 {
     List.Insert(index, value);
 }
Пример #15
0
 /// <summary>
 ///     Removes the affix suffix rule entry for the word if valid
 /// </summary>
 /// <param name="word" type="string">
 ///     <para>
 ///         The word to be modified
 ///     </para>
 /// </param>
 /// <param name="entry" type="NetSpell.SpellChecker.Dictionary.Affix.AffixEntry">
 ///     <para>
 ///         The affix rule entry to use
 ///     </para>
 /// </param>
 /// <returns>
 ///     The word after affix removed.  Will be the same word if affix could not be removed.
 /// </returns>
 /// <remarks>
 ///		This method does not verify that the returned word is a valid word, only that the affix can be removed
 /// </remarks>
 public static string RemoveSuffix(string word, AffixEntry entry)
 {
     int tempLength = word.Length - entry.AddCharacters.Length;
     if ((tempLength > 0)
         &&  (tempLength + entry.StripCharacters.Length >= entry.ConditionCount)
         && (word.EndsWith(entry.AddCharacters)))
     {
         // word with out affix
         string tempWord = word.Substring(0, tempLength);
         // add back strip chars
         tempWord += entry.StripCharacters;
         // check that this is valid
         int passCount = 0;
         for (int i = 0;  i < entry.ConditionCount; i++)
         {
             int charCode = (int)tempWord[tempWord.Length - (entry.ConditionCount - i)];
             if ((entry.Condition[charCode] & (1 << i)) == (1 << i))
             {
                 passCount++;
             }
         }
         if (passCount == entry.ConditionCount)
         {
             return tempWord;
         }
     }
     return word;
 }
 /// <summary>
 ///     Copies the 'AffixEntryCollection' values to a one-dimensional System.Array
 ///     instance starting at the specified array index.
 /// </summary>
 /// <param name='array'>
 ///     The one-dimensional System.Array that represents the copy destination.
 /// </param>
 /// <param name='index'>
 ///     The index in the array where copying begins.
 /// </param>
 public void CopyTo(AffixEntry[] array, int index)
 {
     List.CopyTo(array, index);
 }
Пример #17
0
		/// <summary>
		///     Initializes the dictionary by loading and parsing the
		///     dictionary file and the user file.
		/// </summary>
		public void Initialize()
		{
			// clean up data first
			_baseWords.Clear();
			_replaceCharacters.Clear();
			_prefixRules.Clear();
			_suffixRules.Clear();
			_phoneticRules.Clear();
			_tryCharacters = "";
			

			// the following is used to split a line by white space
			Regex _spaceRegx = new Regex(@"[^\s]+", RegexOptions.Compiled);
			MatchCollection partMatches;

			string currentSection = "";
			AffixRule currentRule = null;
			string dictionaryPath = Path.Combine(_dictionaryFolder, _dictionaryFile);

			TraceWriter.TraceInfo("Loading Dictionary:{0}", dictionaryPath);

			// open dictionary file
			FileStream fs = new FileStream(dictionaryPath, FileMode.Open, FileAccess.Read, FileShare.Read);
			StreamReader sr = new StreamReader(fs, Encoding.UTF8);
			
			// read line by line
			while (sr.Peek() >= 0) 
			{
				string tempLine = sr.ReadLine().Trim();
				if (tempLine.Length > 0)
				{
					// check for section flag
					switch (tempLine)
					{
						case "[Copyright]" :
						case "[Try]" : 
						case "[Replace]" : 
						case "[Prefix]" :
						case "[Suffix]" :
						case "[Phonetic]" :
						case "[Words]" :
							// set current section that is being parsed
							currentSection = tempLine;
							break;
						default :		
							// parse line and place in correct object
						switch (currentSection)
						{
							case "[Copyright]" :
								this.Copyright += tempLine + "\r\n";
								break;
							case "[Try]" : // ISpell try chars
								this.TryCharacters += tempLine;
								break;
							case "[Replace]" : // ISpell replace chars
								this.ReplaceCharacters.Add(tempLine);
								break;
							case "[Prefix]" : // MySpell prefix rules
							case "[Suffix]" : // MySpell suffix rules

								// split line by white space
								partMatches = _spaceRegx.Matches(tempLine);
									
								// if 3 parts, then new rule  
								if (partMatches.Count == 3)
								{
									currentRule = new AffixRule();
									
									// part 1 = affix key
									currentRule.Name = partMatches[0].Value;
									// part 2 = combine flag
									if (partMatches[1].Value == "Y") currentRule.AllowCombine = true;
									// part 3 = entry count, not used

									if (currentSection == "[Prefix]")
									{
										// add to prefix collection
										this.PrefixRules.Add(currentRule.Name, currentRule);
									}
									else 
									{
										// add to suffix collection
										this.SuffixRules.Add(currentRule.Name, currentRule);
									}
								}
									//if 4 parts, then entry for current rule
								else if (partMatches.Count == 4)
								{
									// part 1 = affix key
									if (currentRule.Name == partMatches[0].Value)
									{
										AffixEntry entry = new AffixEntry();

										// part 2 = strip char
										if (partMatches[1].Value != "0") entry.StripCharacters = partMatches[1].Value;
										// part 3 = add chars
										entry.AddCharacters = partMatches[2].Value;
										// part 4 = conditions
										AffixUtility.EncodeConditions(partMatches[3].Value, entry);

										currentRule.AffixEntries.Add(entry);
									}
								}	
								break;
							case "[Phonetic]" : // ASpell phonetic rules
								// split line by white space
								partMatches = _spaceRegx.Matches(tempLine);
								if (partMatches.Count >= 2)
								{
									PhoneticRule rule = new PhoneticRule();
									PhoneticUtility.EncodeRule(partMatches[0].Value, ref rule);
									rule.ReplaceString = partMatches[1].Value;
									_phoneticRules.Add(rule);
								}
								break;
							case "[Words]" : // dictionary word list
								// splits word into its parts
								string[] parts = tempLine.Split('/');
								Word tempWord = new Word();
								// part 1 = base word
								tempWord.Text = parts[0];
								// part 2 = affix keys
								if (parts.Length >= 2) tempWord.AffixKeys = parts[1];
								// part 3 = phonetic code
								if (parts.Length >= 3) tempWord.PhoneticCode = parts[2];
								
								this.BaseWords.Add(tempWord.Text, tempWord);
								break;
						} // currentSection swith
							break;
					} //tempLine switch
				} // if templine
			} // read line
			// close files
			sr.Close();
			fs.Close();

			TraceWriter.TraceInfo("Dictionary Loaded BaseWords:{0}; PrefixRules:{1}; SuffixRules:{2}; PhoneticRules:{3}",
				this.BaseWords.Count, this.PrefixRules.Count, this.SuffixRules.Count, this.PhoneticRules.Count);

			this.LoadUserFile();

			_initialized = true;
		}
Пример #18
0
 /// <summary>
 ///     Gets a value indicating whether the 'AffixEntryCollection' contains the specified value.
 /// </summary>
 /// <param name='value'>
 ///     The item to locate.
 /// </param>
 /// <returns>
 ///     True if the item exists in the collection; false otherwise.
 /// </returns>
 public bool Contains(AffixEntry value)
 {
     return(List.Contains(value));
 }