示例#1
0
        protected override string CodeUnit(Linguistics.Core.UnitTextBase unit)
        {
            string result = CodeByText(unit);

            if (string.IsNullOrEmpty(result))
            {
                switch (unit.UnitTextType)
                {
                case UnitTextType.U:
                    result = CodeUnmarked((UnmarkedText)unit);
                    break;

                case UnitTextType.ENTITY:
                    result = CodeEntity((Entity)unit);
                    break;

                case UnitTextType.CET:
                    result = CodeCeterus((Entity)unit);
                    break;

                case UnitTextType.VERB:
                    result = "verb";
                    break;

                default:
                    throw new ArgumentException("wrong UnitTextType");
                }
            }
            return(result);
        }
示例#2
0
 /// <summary>
 /// Корректировка коллекции юнитов подпредложения
 /// </summary>
 /// <param name="current">текущий юнит</param>
 /// <param name="corrector">преобразователь</param>
 /// <param name="units">юниты для корректировки</param>
 private void CorrectUnits(UnitTextBase current, Corrector corrector, params UnitTextBase[] units)
 {
     if (units.Any())
     {
         List <UnitTextBase> collection = Units.ToList();
         corrector(collection, current, units);
         Units = collection.ToArray();
     }
 }
        /// <summary>
        /// Разрезка юнита на 2
        /// </summary>
        /// <param name="units">список юнитов</param>
        /// <param name="unitIndex">индекс юнита, который надо разрезать</param>
        /// <param name="splitPosition">позиция, по которой надо разрезать юнит</param>
        /// <returns>индекс второй части разрезанного юнита</returns>
        private int SplitUnit(List <UnitTextBase> units, int unitIndex, int splitPosition)
        {
            int          result = unitIndex;
            UnitTextBase unit   = units[result];

            units[result] = SetParentSubSentence(CreateUnmarkedText(unit.Text, 0, splitPosition, unit.PositionInfo.Start), unit.ParentObject);
            ++result;
            units.Insert(result, SetParentSubSentence(CreateUnmarkedText(unit.Text, splitPosition, unit.get_Length(), unit.PositionInfo.Start), unit.ParentObject));
            return(result);
        }
示例#4
0
        /// <summary>
        /// Получение индекса заданного юнита в коллекции.
        /// Юнит должен быть в коллекции
        /// </summary>
        /// <param name="collection">коллекция юнитов</param>
        /// <param name="unit">юнит для поиска</param>
        /// <returns>индекс юнита</returns>
        private int GetIndex(List <UnitTextBase> collection, UnitTextBase unit)
        {
            int result = collection.IndexOf(unit);

            if (result < 0)
            {
                throw new ArgumentException("collection not contain unit");
            }
            return(result);
        }
示例#5
0
        /// <summary>
        /// Добавление заданных юнитов перед текущим
        /// </summary>
        /// <param name="collection">список юнитов</param>
        /// <param name="current">текущий юнит</param>
        /// <param name="units">коллекция добавляемых юнитов</param>
        private void AddBeforeCurrent(List <UnitTextBase> collection, UnitTextBase current, params UnitTextBase[] units)
        {
            units.SetRelations(this);
            int index = GetIndex(collection, current);

            if (index > 0)
            {
                units.First().SetRelation(collection[index - 1]);
            }
            current.SetRelation(units.Last());
            collection.InsertRange(index, units);
        }
示例#6
0
        /// <summary>
        /// Добавление заданных юнитов после текущего
        /// </summary>
        /// <param name="collection">список юнитов</param>
        /// <param name="current">текущий юнит</param>
        /// <param name="units">коллекция добавляемых юнитов</param>
        private void AddAfterCurrent(List <UnitTextBase> collection, UnitTextBase current, params UnitTextBase[] units)
        {
            units.SetRelations(this);
            int index = GetIndex(collection, current) + 1;

            if (index < collection.Count)
            {
                collection[index].SetRelation(units.Last());
            }
            units.First().SetRelation(current);
            collection.InsertRange(index, units);
        }
 /// <summary>
 /// Присоединение дочернего юнита к сущности
 /// </summary>
 /// <param name="unit">дочерний юнит</param>
 public void AppendChild(UnitTextBase unit)
 {
     if (_positionInfo.Start < 0)
     {
         _positionInfo.Start = unit.PositionInfo.Start;
     }
     _positionInfo.End = unit.PositionInfo.End;
     Text += unit.Text;
     if (unit.IsEntity)
     {
         AddChild((Entity)unit);
     }
 }
 /// <summary>
 /// Присоединение дочернего юнита в начало сущности
 /// </summary>
 /// <param name="unit">дочерний юнит</param>
 public void AppendChildToBegin(UnitTextBase unit)
 {
     #region [.defense.]
     if (unit.PositionInfo.End != _positionInfo.Start)
     {
         throw new ArgumentException("isn't near unit");
     }
     #endregion
     _positionInfo.Start = unit.PositionInfo.Start;
     Text = Text.Insert(0, unit.Text);
     if (unit.IsEntity)
     {
         AddChild((Entity)unit);
     }
 }
示例#9
0
        /// <summary>
        /// Удаление текущего юнита
        /// </summary>
        /// <param name="collection">список юнитов</param>
        /// <param name="current">текущий юнит</param>
        /// <param name="units">не используется</param>
        private void RemoveCurrent(List <UnitTextBase> collection, UnitTextBase current, params UnitTextBase[] units)
        {
            int          index    = GetIndex(collection, current);
            UnitTextBase previous = (index > 0) ? collection[index - 1] : null;
            UnitTextBase next     = (index < collection.Count - 1) ? collection[index + 1] : null;

            if (previous != null)
            {
                previous.Next = next;
            }
            if (next != null)
            {
                next.Previous = previous;
            }
            collection.RemoveAt(index);
        }
        /// <summary>
        /// Поиск индекса юнита, в который попадает позиция контента
        /// </summary>
        /// <param name="contentIndex">индекс контента</param>
        /// <param name="units">коллекция юнитов</param>
        /// <param name="startUnitIndex">индекс юнита, с которого начинается поиск</param>
        /// <returns>индекс юнита</returns>
        private int FindUnitIndexForContent(int contentIndex, IList <UnitTextBase> units, int startUnitIndex)
        {
            int result       = startUnitIndex;
            int contentStart = Children[contentIndex].StartPosition;

            while (result < units.Count)
            {
                UnitTextBase unit = units[result];
                if ((unit.GetFullStartPosition() <= contentStart) && (contentStart < unit.GetFullEndPosition()))
                /// контент начинается внутри юнита
                {
                    break;
                }
                ++result;
            }
            return(result);
        }
 /// <summary>
 /// Задание родительского подпредложения для заданного юнита
 /// </summary>
 /// <param name="unit">юнит</param>
 /// <param name="parentSubSentence">родительское предложение</param>
 /// <returns>юнит</returns>
 private UnitTextBase SetParentSubSentence(UnitTextBase unit, SubSentence parentSubSentence)
 {
     unit.ParentObject = parentSubSentence;
     return(unit);
 }
 /// <summary>
 /// Получение длины юнита
 /// </summary>
 /// <param name="unit">юнит</param>
 /// <returns>длина юнита</returns>
 public static int get_Length(this UnitTextBase unit)
 {
     return(unit.PositionInfo.End - unit.PositionInfo.Start);
 }
示例#13
0
 /// <summary>
 /// Добавление заданного юнита перед текущим
 /// </summary>
 /// <param name="current">текущий юнит</param>
 /// <param name="unit">добавляемый юнит</param>
 public void AddBeforeCurrent(UnitTextBase current, UnitTextBase unit)
 {
     CorrectUnits(current, AddBeforeCurrent, unit);
 }
 /// <summary>
 /// Конец юнита относительного целого текста
 /// </summary>
 /// <param name="unit">юнит</param>
 /// <returns>конец юнита</returns>
 public static int GetFullEndPosition(this UnitTextBase unit)
 {
     return(unit.PositionInfo.End + unit.ParentObject.ParentObject.StartPosition);
 }
示例#15
0
 /// <summary>
 /// Добавление заданного юнита после текущего
 /// </summary>
 /// <param name="current">текущий юнит</param>
 /// <param name="unit">добавляемый юнит</param>
 public void AddAfterCurrent(UnitTextBase current, UnitTextBase unit)
 {
     CorrectUnits(current, AddAfterCurrent, unit);
 }
示例#16
0
 /// <summary>
 /// Удаление текущего юнита
 /// </summary>
 /// <param name="current">текущий юнит</param>
 public void RemoveCurrent(UnitTextBase current)
 {
     CorrectUnits(current, RemoveCurrent);
 }
示例#17
0
 /// <summary>
 /// Замена текущего юнита заданными
 /// </summary>
 /// <param name="collection">список юнитов</param>
 /// <param name="current">текущий юнит</param>
 /// <param name="units">коллекция юнитов для замены</param>
 private void ReplaceCurrentWith(List <UnitTextBase> collection, UnitTextBase current, params UnitTextBase[] units)
 {
     AddAfterCurrent(collection, current, units);
     RemoveCurrent(collection, current);
 }
示例#18
0
 /// <summary>
 /// Замена в предложении текущего юнита заданными
 /// </summary>
 /// <param name="current">текущий юнит</param>
 /// <param name="units">юниты для замены</param>
 public void ReplaceCurrentWith(UnitTextBase current, params UnitTextBase[] units)
 {
     CorrectUnits(current, ReplaceCurrentWith, units);
 }