public string GetFirstValue(int patternIndex)
        {
            StateItem item  = States[0];
            int       index = GetFirstMatchedIndex(patternIndex);
            string    value = item.GetEntityValue(index - StartIndex);

            if (value == null)
            {
                value = Entities[index].Value;
            }
            return(value);
        }
Esempio n. 2
0
 /// <summary>
 /// Adds passed indexes to StateItem.
 /// </summary>
 /// <param name="patternIndex">Index of passed pattern.</param>
 /// <param name="subStateItem">Passed indexes in sub pattern.</param>
 /// <param name="passedIndex">Only this index will be added to passed.</param>
 public void AddPassed(int patternIndex, StateItem subStateItem, int passedIndex, string value)
 {
     for (int i = 0; i < subStateItem.CountOfPassedEntities; i++)
     {
         if (subStateItem.Passed[i] == passedIndex)
         {
             if (value != null)
             {
                 SetEntityValue(NextEntityIndex, value);
             }
             Passed.Add(patternIndex);
         }
         else
         {
             Passed.Add(-1);
         }
     }
 }
        public List <IEntity>[] GetMatch()
        {
            List <IEntity>[] result = new List <IEntity> [ParentRegex.AllRegex.Length];

            StateItem item = States[0];

            for (int entityIndex = 0; entityIndex < item.Passed.Count; entityIndex++)
            {
                int patternIndex = item.Passed[entityIndex];
                if (patternIndex == -1)
                {
                    continue;
                }
                if (result[patternIndex] == null)
                {
                    result[patternIndex] = new List <IEntity>();
                }

                result[patternIndex].Add(Entities[StartIndex + entityIndex]);
            }
            return(result);
        }
        public override EntityRegexMatchState Interpret(EntityRegexMatchInfo info, EntityRegexMatchState state)
        {
            if (state == null || state.Count == 0)
            {
                return(null);
            }

            EntityRegexMatchState result = new EntityRegexMatchState();

            //foeach Regex (ClauseHolder item) in ClauseHolder
            foreach (ClauseHolder.ClauseItem clauseHolderItem in Holder.Items)
            {
                //foreach stateItem in original state
                foreach (StateItem stateItem in state)
                {
                    if (info.StartIndex + stateItem.NextEntityIndex < info.Entities.Length)
                    {
                        //evaluate regex
                        EntityRegexMatchInfo temp = clauseHolderItem.Regex.Interpret(info.Entities, info.StartIndex + stateItem.NextEntityIndex);
                        if (temp.States != null)
                        {
                            //foreach stateItem in evaluated result
                            foreach (StateItem subStateItem in temp.States)
                            {
                                //new state item
                                StateItem tempStateItem = new StateItem(stateItem);
                                //item passed for current pattern index, subStateItem only clauseHolderItem.Index indexes.
                                tempStateItem.AddPassed(info.CurrentPatternIndex, subStateItem, clauseHolderItem.Index, clauseHolderItem.Value);
                                result.Add(tempStateItem);
                            }
                        }
                    }
                }
            }
            return(result);
        }
Esempio n. 5
0
 public StateItem(StateItem item)
 {
     Passed = new List <int>(item.Passed);
 }
Esempio n. 6
0
 /// <summary>
 /// Adds passed indexes to StateItem.
 /// </summary>
 /// <param name="patternIndex">Index of passed pattern.</param>
 /// <param name="subStateItem">Passed indexes in sub pattern.</param>
 /// <param name="passedIndex">Only this index will be added to passed.</param>
 public void AddPassed(int patternIndex, StateItem subStateItem, int passedIndex)
 {
     AddPassed(patternIndex, subStateItem, patternIndex, null);
 }
 public bool NextEntityExists(StateItem stateItem)
 {
     return(StartIndex + stateItem.NextEntityIndex < Entities.Length);
 }
 public IEntity GetNextEntity(StateItem stateItem)
 {
     return(Entities[StartIndex + stateItem.NextEntityIndex]);
 }