コード例 #1
0
        public static bool TryParseModifier(
            IEnumerable <string> values,
            string optionName,
            [NotNullWhen(true)] out EnumerableModifier <string>?modifier)
        {
            modifier = null;

            if (!values.Any())
            {
                return(false);
            }

            string value = values.First();

            if (!TryParseAsEnumFlags(
                    values.Skip(1),
                    optionName,
                    out ModifierOptions options,
                    ModifierOptions.None,
                    OptionValueProviders.ModifierOptionsProvider))
            {
                return(false);
            }

            if ((options & ModifierOptions.FromFile) != 0 &&
                !FileSystemHelpers.TryReadAllText(value, out value !, ex => WriteError(ex)))
            {
                return(false);
            }

            if ((options & ModifierOptions.FromDll) != 0)
            {
                return(DelegateFactory.TryCreateFromAssembly(
                           value,
                           typeof(IEnumerable <string>),
                           typeof(IEnumerable <string>),
                           out modifier));
            }
            else if ((options & ModifierOptions.FromFile) != 0)
            {
                return(DelegateFactory.TryCreateFromSourceText(
                           value,
                           typeof(IEnumerable <string>),
                           typeof(IEnumerable <string>),
                           out modifier));
            }
            else
            {
                return(DelegateFactory.TryCreateFromExpression(
                           value,
                           "ModifierClass",
                           "ModifierMethod",
                           "IEnumerable<string>",
                           typeof(IEnumerable <string>),
                           "IEnumerable<string>",
                           typeof(IEnumerable <string>),
                           "items",
                           out modifier));
            }
        }
コード例 #2
0
        public static bool TryParseReplacement(
            IEnumerable <string> values,
            out string?replacement,
            out MatchEvaluator?matchEvaluator)
        {
            replacement    = null;
            matchEvaluator = null;

            if (!values.Any())
            {
                return(true);
            }

            string value = values.First();

            if (!TryParseAsEnumFlags(
                    values.Skip(1),
                    OptionNames.Replacement,
                    out ReplacementOptions options,
                    ReplacementOptions.None,
                    OptionValueProviders.ReplacementOptionsProvider))
            {
                return(false);
            }

            if ((options & ReplacementOptions.FromFile) != 0 &&
                !FileSystemHelpers.TryReadAllText(value, out value !, ex => WriteError(ex)))
            {
                return(false);
            }

            if ((options & ReplacementOptions.CSharp) != 0)
            {
                if ((options & ReplacementOptions.FromFile) != 0)
                {
                    return(DelegateFactory.TryCreateFromSourceText(value, typeof(string), typeof(Match), out matchEvaluator));
                }
                else
                {
                    return(DelegateFactory.TryCreateFromExpression(
                               value,
                               "EvaluatorClass",
                               "EvaluatorMethod",
                               "string",
                               typeof(string),
                               "Match",
                               typeof(Match),
                               "match",
                               out matchEvaluator));
                }
            }
            else if ((options & ReplacementOptions.FromDll) != 0)
            {
                return(DelegateFactory.TryCreateFromAssembly(value, typeof(string), typeof(Match), out matchEvaluator));
            }
            else
            {
                replacement = value;

                if ((options & ReplacementOptions.Literal) != 0)
                {
                    replacement = RegexEscape.EscapeSubstitution(replacement);
                }

                if ((options & ReplacementOptions.Escape) != 0)
                {
                    replacement = RegexEscape.ConvertCharacterEscapes(replacement);
                }
            }

            return(true);
        }