/// <summary>
        /// Выделение чисел с запятой
        /// </summary>
        /// <param name="units">коллекция юнитов</param>
        /// <param name="language">язык текста</param>
        /// <returns>модифицированная коллекция юнитов</returns>
        private UnitTextBase[] SelectFloatNumeric(IEnumerable <UnitTextBase> units, string language)
        {
            List <UnitTextBase> result = new List <UnitTextBase>(units);
            string coded   = _coder.CodeUnits(units);
            int    startAt = 0;
            Match  match   = null;

            while ((match = _floatNumeric.Match(coded, startAt)).Success)
            {
                var replacedUnits = _coder.GetUnits(match.Index, match.Length);
                if (IsFloatNumber(replacedUnits))
                {
                    int    index        = result.IndexOf(replacedUnits.First());
                    Entity floatNumeric = CreateFloatNumeric(replacedUnits, match, language);
                    floatNumeric.ParentObject = replacedUnits.First().ParentObject;
                    result.RemoveRange(index, replacedUnits.Length);
                    result.Insert(index, floatNumeric);
                    startAt = match.Index + match.Length;
                }
                else
                {
                    startAt = match.Index + 1;
                }
            }
            return(result.ToArray());
        }
 /// <summary>
 /// Получение числа из группы
 /// </summary>
 /// <param name="group">группа</param>
 /// <param name="coder">кодер юнитов</param>
 /// <returns>число</returns>
 protected Entity GetNumber(Group group, UnitCoderBase coder)
 {
     foreach (UnitTextBase unit in coder.GetUnits(group.Index, group.Length))
     {
         if (unit.IsEntity)
         {
             Entity entity = (Entity)unit;
             if (entity.IsNumber())
             {
                 return(entity);
             }
         }
     }
     throw new InvalidOperationException("can't find numeric unit");
 }
        /// <summary>
        /// Выделение из текста интервалов чисел
        /// </summary>
        /// <param name="text">текст</param>
        /// <param name="coder">кодер юнитов</param>
        /// <returns>интервалы чисел</returns>
        public NumberRange[] GetNumberRanges(string text, UnitCoderBase coder)
        {
            List <NumberRange> result = new List <NumberRange>();
            var collection            = Expression.Matches(text);

            for (int i = 0; i < collection.Count; ++i)
            {
                var range = GetNumberRange(collection[i], coder);
                var units = coder.GetUnits(collection[i].Index, collection[i].Length);
                range.StartPosition = units.First().PositionInfo.Start;
                range.EndPosition   = units.Last().PositionInfo.End;
                range.Text          = units.GetTextWithSubText();
                result.Add(range);
            }
            return(result.ToArray());
        }
예제 #4
0
        /// <summary>
        /// Замена юнитов в коллекции на цепочки однородных сущностей
        /// </summary>
        /// <param name="unitCollection">коллекция юнитов</param>
        public void ReplaceWithHomogeneous(IList <UnitTextBase> collection)
        {
            string codedString = _coder.CodeUnits(collection);

            int   startAt = 0;
            Match match   = null;

            while ((match = _regex.Match(codedString, startAt)).Success)
            {
                var chain = new HomogeneousChain(_coder.GetUnits(match.Index, match.Length), this);
                if (chain.Success)
                {
                    chain.ReplaceUnits(collection);
                    startAt = match.Index + match.Length;
                }
                else
                {
                    startAt = match.Index + 1;
                }
            }
        }