Пример #1
0
        internal static MatchData Create(
            string input,
            Regex regex,
            Match match,
            int maxCount = -1,
            CancellationToken cancellationToken = default)
        {
            var groupDefinitions = new GroupDefinitionCollection(regex);

            var items = new List <MatchItem>();

            int max = (maxCount < 0) ? int.MaxValue : maxCount;

            while (match.Success &&
                   items.Count < max)
            {
                cancellationToken.ThrowIfCancellationRequested();

                var item = new MatchItem(match, groupDefinitions);
                items.Add(item);
                match = match.NextMatch();
            }

            return(new MatchData(regex, input, maxCount, new MatchItemCollection(items), groupDefinitions));
        }
Пример #2
0
 private SplitData(Regex regex, string input, int maxCount, SplitItemCollection items, bool omitGroups, GroupDefinitionCollection groupDefinitions)
 {
     Regex            = regex;
     Input            = input;
     MaxCount         = maxCount;
     GroupDefinitions = groupDefinitions;
     OmitGroups       = omitGroups;
     Items            = items;
 }
Пример #3
0
 private MatchData(
     Regex regex,
     string input,
     int maxCount,
     MatchItemCollection items,
     GroupDefinitionCollection groupDefinitions)
 {
     Regex            = regex;
     Input            = input;
     MaxCount         = maxCount;
     Items            = items;
     GroupDefinitions = groupDefinitions;
 }
Пример #4
0
        internal MatchItem(Match match, GroupDefinitionCollection groups)
        {
            Match = match;

            var items = new List <GroupItem>(groups.Count);

            foreach (GroupDefinition group in groups)
            {
                items.Add(new GroupItem(Match.Groups[group.Number], group, this));
            }

            GroupItems = new GroupItemCollection(items);
        }
Пример #5
0
        public static SplitData Create(
            Regex regex,
            string input,
            int count       = 0,
            bool omitGroups = false,
            CancellationToken cancellationToken = default)
        {
            if (regex == null)
            {
                throw new ArgumentNullException(nameof(regex));
            }

            if (input == null)
            {
                throw new ArgumentNullException(nameof(input));
            }

            var groupDefinitions = new GroupDefinitionCollection(regex);

            List <SplitItem> items = GetItems(regex, input, count, groupDefinitions, omitGroups, cancellationToken);

#if DEBUG
            List <SplitItem> items2 = GetItems(regex, input, count, groupDefinitions, omitGroups: false, cancellationToken);

            string[] splits = regex.Split(input, count);

            Debug.Assert(splits.Length == items2.Count, items2.Count.ToString() + " " + splits.Length.ToString());

            for (int i = 0; i < items2.Count; i++)
            {
                if (items2[i].Value != splits[i])
                {
                    Debug.WriteLine(i);
                    Debug.WriteLine(splits[i]);
                    Debug.WriteLine(items2[i].Value);
                    Debug.Fail("");
                }
            }
#endif

            return(new SplitData(regex, input, count, new SplitItemCollection(items), omitGroups, groupDefinitions));
        }
Пример #6
0
        private static List <SplitItem> GetItems(Regex regex, string input, int maxCount, GroupDefinitionCollection groupDefinitions, bool omitGroups, CancellationToken cancellationToken)
        {
            var splits = new List <SplitItem>();

            if (maxCount == 1)
            {
                splits.Add(SplitItem.Create(input));
                return(splits);
            }

            Match firstMatch = regex.Match(input);

            if (!firstMatch.Success)
            {
                splits.Add(SplitItem.Create(input));
                return(splits);
            }

            int prevIndex   = 0;
            int count       = 0;
            int splitNumber = 1;

            foreach (Match match in EnumerateMatches(regex, firstMatch, maxCount, cancellationToken))
            {
                splits.Add(SplitItem.Create(input.Substring(prevIndex, match.Index - prevIndex), prevIndex, splitNumber));
                count++;
                splitNumber++;
                prevIndex = match.Index + match.Length;

                if (!omitGroups)
                {
                    if (regex.RightToLeft)
                    {
                        for (int i = (groupDefinitions.Count - 1); i >= 0; i--)
                        {
                            if (groupDefinitions[i].Number != 0)
                            {
                                Group group = match.Groups[groupDefinitions[i].Number];
                                if (group.Success)
                                {
                                    splits.Add(SplitItem.Create(group, groupDefinitions[i]));
                                    count++;
                                }
                            }
                        }
                    }
                    else
                    {
                        foreach (GroupDefinition groupDefinition in groupDefinitions)
                        {
                            if (groupDefinition.Number != 0)
                            {
                                Group group = match.Groups[groupDefinition.Number];
                                if (group.Success)
                                {
                                    splits.Add(SplitItem.Create(group, groupDefinition));
                                    count++;
                                }
                            }
                        }
                    }
                }
            }

            splits.Add(SplitItem.Create(input.Substring(prevIndex, input.Length - prevIndex), prevIndex, splitNumber));
            return(splits);
        }