Exemplo n.º 1
0
        /// <summary>
        /// Build name from captured part values.
        /// </summary>
        /// <param name="pattern"></param>
        /// <param name="parts"></param>
        /// <returns>Built name, or null if one of the required parts were not found.</returns>
        public static string Print(this ILinePattern pattern, IReadOnlyDictionary <string, string> parts)
        {
            // Count chars
            int length = 0;

            foreach (ILinePatternPart part in pattern.AllParts)
            {
                if (part.Text != null)
                {
                    length += part.Text.Length;
                }
                else
                {
                    string value = null;
                    if (parts.TryGetValue(part.Identifier, out value) && !string.IsNullOrEmpty(value))
                    {
                        length += part.PrefixSeparator.Length + part.PostfixSeparator.Length + value.Length;
                    }
                    else if (part.Required)
                    {
                        return(null);
                    }
                }
            }

            // Put together string
            // .. without StringBuilder, there needs to be efficiencies since this may be called frequently.
            int ix = 0;

            char[] chars = new char[length];
            foreach (ILinePatternPart part in pattern.AllParts)
            {
                if (part.Text != null)
                {
                    part.Text.CopyTo(0, chars, ix, part.Text.Length); ix += part.Text.Length;
                }
                else
                {
                    string value = null;
                    if (parts.TryGetValue(part.Identifier, out value))
                    {
                        if (string.IsNullOrEmpty(value))
                        {
                            if (part.Required)
                            {
                                return(null);
                            }
                            else
                            {
                                continue;
                            }
                        }
                        part.PrefixSeparator.CopyTo(0, chars, ix, part.PrefixSeparator.Length); ix += part.PrefixSeparator.Length;
                        value.CopyTo(0, chars, ix, value.Length); ix += value.Length;
                        part.PostfixSeparator.CopyTo(0, chars, ix, part.PostfixSeparator.Length); ix += part.PostfixSeparator.Length;
                    }
                }
            }
            return(new string(chars));
        }
Exemplo n.º 2
0
        /// <summary>
        /// Create tree structure from source of flat key values.
        /// </summary>
        /// <param name="lines"></param>
        /// <param name="groupingPolicy"></param>
        /// <param name="parameterInfos"></param>
        /// <returns>tree root ""</returns>
        public static LineTree Create(IEnumerable <ILine> lines, ILinePattern groupingPolicy, IParameterInfos parameterInfos)
        {
            LineTree root = new LineTree(new LinePart(LineAppender.NonResolving, null));

            root.AddRange(lines, groupingPolicy, parameterInfos);
            return(root);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Construct regular expression with half filled parameters
        /// </summary>
        /// <param name="pattern"></param>
        /// <param name="filledParameters"></param>
        /// <returns></returns>
        public static Regex BuildRegex(this ILinePattern pattern, IReadOnlyDictionary <string, string> filledParameters)
        {
            string       pattern_text = pattern.BuildRegexString(filledParameters);
            RegexOptions options      = RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture;

            if (filledParameters == null || filledParameters.Count == 0)
            {
                options |= RegexOptions.Compiled;
            }
            return(new Regex(pattern_text, options));
        }
Exemplo n.º 4
0
 private void OnMultiLinePatternSelectionChanged(LinePattern selected)
 {
     isChangingMultipleAttributes = true;
     using (frame.Project.Undo.UndoFrame)
     {
         for (int i = 0; i < selectedObjects.Count; ++i)
         {
             ILinePattern ilp = selectedObjects[i] as ILinePattern;
             if (ilp != null)
             {
                 ilp.LinePattern = selected;
             }
         }
     }
     isChangingMultipleAttributes = false;
     MultiChangeDone();
 }
        public LinePatternSelectionProperty(string ResourceID, LinePatternList linePatternList, ILinePattern iLinePattern, bool includeUndefined)
        {
            this.linePatternList = linePatternList;
            resourceId           = ResourceID;
            LinePattern select = iLinePattern.LinePattern;

            if (includeUndefined)
            {
                choices = new string[linePatternList.Count + 1];
                for (int i = 0; i < linePatternList.Count; ++i)
                {
                    choices[i + 1] = linePatternList[i].Name;
                }
                string undef = StringTable.GetString("LinePattern.Undefined");
                // sollte es den Namen schon geben, werden solange - davor und dahintergemacht, bis es den Namen mehr gibt
                while (linePatternList.Find(undef) != null)
                {
                    undef = "-" + undef + "-";
                }
                choices[0] = undef;
                if (select != null)
                {
                    base.selectedText = select.Name;
                }
                else
                {
                    base.selectedText = undef;
                }
            }
            else
            {
                choices = new string[linePatternList.Count];
                for (int i = 0; i < linePatternList.Count; ++i)
                {
                    choices[i] = linePatternList[i].Name;
                }
                if (select != null)
                {
                    base.selectedText = select.Name;
                }
            }
            this.iLinePattern = iLinePattern;
            toWatch           = iLinePattern as IGeoObject;
        }
Exemplo n.º 6
0
        /// <summary>
        /// Match against string or filename.
        /// </summary>
        /// <param name="pattern"></param>
        /// <param name="text"></param>
        /// <param name="filledParameters"></param>
        /// <returns>match object</returns>
        public static ILinePatternMatch Match(this ILinePattern pattern, string text, IReadOnlyDictionary <string, string> filledParameters = null)
        {
            bool hasFilledParameters = false;

            if (filledParameters != null && filledParameters.Count > 0)
            {
                foreach (var kp in filledParameters)
                {
                    if (kp.Value != null)
                    {
                        hasFilledParameters = true; break;
                    }
                }
            }
            Regex regex = hasFilledParameters ? pattern.Regex : pattern.BuildRegex(filledParameters);

            System.Text.RegularExpressions.Match match = regex.Match(text);
            LinePatternMatch _match = new LinePatternMatch(pattern);

            if (match.Success)
            {
                foreach (ILinePatternPart part in pattern.CaptureParts)
                {
                    string prefilled_value;
                    if (hasFilledParameters && filledParameters.TryGetValue(part.Identifier, out prefilled_value))
                    {
                        _match.PartValues[part.CaptureIndex] = prefilled_value;
                    }
                    else
                    {
                        Group g = match.Groups[part.Identifier];
                        if (g.Success)
                        {
                            _match.PartValues[part.CaptureIndex] = g.Value;
                        }
                    }
                }
            }
            return(_match);
        }
Exemplo n.º 7
0
 /// <summary>
 /// Test if <paramref name="parameters"/> fill all required parameters of <paramref name="pattern"/>.
 /// </summary>
 /// <param name="pattern"></param>
 /// <param name="parameters"></param>
 /// <param name="allParts">if true tests if all capture parts match, if false, if non-optional parts match</param>
 /// <returns></returns>
 public static bool TestSuccess(this ILinePattern pattern, IReadOnlyDictionary <string, string> parameters, bool allParts)
 {
     if (parameters == null)
     {
         return(false);
     }
     foreach (var part in pattern.CaptureParts)
     {
         if (!allParts && !part.Required)
         {
             continue;
         }
         string value;
         if (!parameters.TryGetValue(part.Identifier, out value))
         {
             return(false);
         }
         if (value == null)
         {
             return(false);
         }
     }
     return(true);
 }
Exemplo n.º 8
0
 /// <summary>
 /// Checks whether an <see cref="IGeoObject"/> is accepted by this filter.
 /// To realize custom filters, override this method.
 /// </summary>
 /// <param name="go">The object beeing tested</param>
 /// <returns>true if accepted, fale otherwise</returns>
 public virtual bool Accept(IGeoObject go)
 {
     // jetzt so implementiert: wenn ein Attribut verlangt wird und ein Objekt nicht das
     // passende Interface hat, dann wird es nicht akzeptiert
     // wenn z.B. der Layer eines Objektes null ist, dann wird dieses von keinem Filter anerkannt
     if (acceptedLayers.Count > 0)
     {
         ILayer ilayer = go as ILayer;
         if (ilayer == null)
         {
             return(false);
         }
         if (ilayer.Layer == null)
         {
             return(false);
         }
         if (!acceptedLayers.ContainsKey(ilayer.Layer))
         {
             return(false);
         }
     }
     if (acceptedColorDefs.Count > 0)
     {
         IColorDef iColorDef = go as IColorDef;
         if (iColorDef == null)
         {
             return(false);
         }
         if (iColorDef.ColorDef == null)
         {
             return(false);
         }
         if (!acceptedColorDefs.ContainsKey(iColorDef.ColorDef))
         {
             return(false);
         }
     }
     if (acceptedLineWidths.Count > 0)
     {
         ILineWidth iLineWidth = go as ILineWidth;
         if (iLineWidth == null)
         {
             return(false);
         }
         if (iLineWidth.LineWidth == null)
         {
             return(false);
         }
         if (!acceptedLineWidths.ContainsKey(iLineWidth.LineWidth))
         {
             return(false);
         }
     }
     if (acceptedLinePatterns.Count > 0)
     {
         ILinePattern iLinePattern = go as ILinePattern;
         if (iLinePattern == null)
         {
             return(false);
         }
         if (iLinePattern.LinePattern == null)
         {
             return(false);
         }
         if (!acceptedLinePatterns.ContainsKey(iLinePattern.LinePattern))
         {
             return(false);
         }
     }
     if (acceptedDimensionStyles.Count > 0)
     {
         IDimensionStyle iDimensionStyle = go as IDimensionStyle;
         if (iDimensionStyle == null)
         {
             return(false);
         }
         if (iDimensionStyle.DimensionStyle == null)
         {
             return(false);
         }
         if (!acceptedDimensionStyles.ContainsKey(iDimensionStyle.DimensionStyle))
         {
             return(false);
         }
     }
     if (acceptedHatchStyles.Count > 0)
     {
         IHatchStyle iHatchStyle = go as IHatchStyle;
         if (iHatchStyle == null)
         {
             return(false);
         }
         if (iHatchStyle.HatchStyle == null)
         {
             return(false);
         }
         if (!acceptedHatchStyles.ContainsKey(iHatchStyle.HatchStyle))
         {
             return(false);
         }
     }
     if (acceptedTypes.Count > 0)
     {
         if (!acceptedTypes.ContainsKey(go.GetType()))
         {
             return(false);
         }
     }
     return(true);
 }
Exemplo n.º 9
0
 /// <summary>
 /// Create abstract file source.
 /// </summary>
 /// <param name="path"></param>
 /// <param name="filePattern"></param>
 public FilePatternSource(string path, ILinePattern filePattern)
 {
     this.Path        = path ?? throw new ArgumentNullException(nameof(path));
     this.FilePattern = filePattern ?? throw new ArgumentNullException(nameof(FilePattern));
 }
Exemplo n.º 10
0
        public void InitMultiAttributeSelection()
        {
            if (multiLinePattern == null)
            {
                return;
            }
            LinePattern commonLinePattern = null;
            bool        linePatternValid  = true;

            for (int i = 0; i < selectedObjects.Count; ++i)
            {
                ILinePattern ilp = selectedObjects[i] as ILinePattern;
                if (linePatternValid && ilp != null)
                {
                    if (commonLinePattern == null)
                    {
                        commonLinePattern = ilp.LinePattern;
                    }
                    else
                    {
                        linePatternValid = (ilp.LinePattern != null) && (commonLinePattern == ilp.LinePattern);
                    }
                }
            }
            if (linePatternValid && commonLinePattern != null)
            {
                multiLinePattern.SetSelection(frame.Project.LinePatternList.FindIndex(commonLinePattern));
            }
            else
            {
                multiLinePattern.SetSelection(-1);
            }

            LineWidth commonLineWidth = null;
            bool      lineWidthValid  = true;

            for (int i = 0; i < selectedObjects.Count; ++i)
            {
                ILineWidth ilp = selectedObjects[i] as ILineWidth;
                if (lineWidthValid && ilp != null)
                {
                    if (commonLineWidth == null)
                    {
                        commonLineWidth = ilp.LineWidth;
                    }
                    else
                    {
                        lineWidthValid = (ilp.LineWidth != null) && (commonLineWidth == ilp.LineWidth);
                    }
                }
            }
            if (lineWidthValid && commonLineWidth != null)
            {
                multiLineWidth.SetSelection(frame.Project.LineWidthList.FindIndex(commonLineWidth));
            }
            else
            {
                multiLineWidth.SetSelection(-1);
            }

            Layer commonLayer = null;
            bool  LayerValid  = true;

            for (int i = 0; i < selectedObjects.Count; ++i)
            {
                ILayer ily = selectedObjects[i] as ILayer;
                if (LayerValid && ily != null)
                {
                    if (commonLayer == null)
                    {
                        commonLayer = ily.Layer;
                    }
                    else
                    {
                        LayerValid = (ily.Layer != null) && (commonLayer == ily.Layer);
                    }
                }
            }
            if (LayerValid && commonLayer != null)
            {
                multiLayer.SetSelection(frame.Project.LayerList.FindIndex(commonLayer));
            }
            else
            {
                multiLayer.SetSelection(-1);
            }

            ColorDef commonColorDef = null;
            bool     ColorDefValid  = true;

            for (int i = 0; i < selectedObjects.Count; ++i)
            {
                IColorDef ily = selectedObjects[i] as IColorDef;
                if (ColorDefValid && ily != null)
                {
                    if (commonColorDef == null)
                    {
                        commonColorDef = ily.ColorDef;
                    }
                    else
                    {
                        ColorDefValid = (ily.ColorDef != null) && (commonColorDef == ily.ColorDef);
                    }
                }
            }
            if (ColorDefValid && commonColorDef != null)
            {
                multiColorDef.SetSelection(frame.Project.ColorList.FindIndex(commonColorDef));
            }
            else
            {
                multiColorDef.SetSelection(-1);
            }

            Style commonStyle = null;
            bool  StyleValid  = true;

            for (int i = 0; i < selectedObjects.Count; ++i)
            {
                IStyle ily = selectedObjects[i] as IStyle;
                if (StyleValid && ily != null)
                {
                    if (commonStyle == null)
                    {
                        commonStyle = ily.Style;
                    }
                    else
                    {
                        StyleValid = (ily.Style != null) && (commonStyle == ily.Style);
                    }
                }
            }
            if (StyleValid && commonStyle != null)
            {
                multiStyle.SetSelection(frame.Project.StyleList.FindIndex(commonStyle));
            }
            else
            {
                multiStyle.SetSelection(-1);
            }
        }
Exemplo n.º 11
0
        /// <summary>
        /// Add an enumeration of key,value pairs. Each key will constructed a new node.
        ///
        /// If <paramref name="groupingRule"/> the nodes are laid out in the order occurance of name pattern parts.
        ///
        /// For example grouping pattern "{Type}/{Culture}{anysection}{Key}" would order nodes as following:
        /// <code>
        ///  "type:MyController": {
        ///      "key:Success": "Success",
        ///      "culture:en:key:Success": "Success",
        ///  }
        /// </code>
        ///
        /// Non-capture parts such as "/" in pattern "{Section}/{Culture}", specify separator of tree node levels.
        ///
        /// </summary>
        /// <param name="tree"></param>
        /// <param name="lines"></param>
        /// <param name="groupingRule"></param>
        /// <param name="parameterInfos"></param>
        /// <returns></returns>
        public static ILineTree AddRange(this ILineTree tree, IEnumerable <ILine> lines, ILinePattern groupingRule, IParameterInfos parameterInfos) // Todo separate to sortRule + groupingRule
        {
            // Use another method
            //if (groupingRule == null) { node.AddRange(lines); return node; }
            StructList16 <ILineParameter> parameters = new StructList16 <ILineParameter>(null);

            foreach (var line in lines)
            {
                parameters.Clear();
                line.GetParameterParts(ref parameters);
                parameterListSorter.Reverse(ref parameters);

                // Key for the current level.
                ILine levelKey = null;
                // Build levels with this collection
                List <ILine> key_levels = new List <ILine>();
                // Visit both lists concurrently
                ILineParameter next_parameter = default;
                if (groupingRule != null)
                {
                    foreach (var part in groupingRule.AllParts)
                    {
                        // Is not a capture part
                        if (part.CaptureIndex < 0)
                        {
                            // Non-capture part has "/", go to next level. eg. "{nn}/{nn}"
                            if (part.Text != null && part.Text.Contains("/"))
                            {
                                if (levelKey != null)
                                {
                                    key_levels.Add(levelKey);
                                }
                                levelKey = null;
                            }
                            // Next part
                            continue;
                        }
                        // Capture part has "/" in prefix, start next level
                        if (levelKey != null && part.PrefixSeparator.Contains("/"))
                        {
                            if (levelKey != null)
                            {
                                key_levels.Add(levelKey);
                            }
                            levelKey = null;
                        }

                        // Look ahead to see if there is a parameter that matches this capture part
                        int next_parameter_ix = -1;
                        for (int ix = 0; ix < parameters.Count; ix++)
                        {
                            // Copy
                            next_parameter = parameters[ix];
                            // Already added before
                            if (next_parameter.ParameterName == null)
                            {
                                continue;
                            }
                            // Get name
                            string parameter_name = next_parameter.ParameterName;
                            // Parameter matches the name in the pattern's capture part
                            if (parameter_name == part.ParameterName)
                            {
                                next_parameter_ix = ix; break;
                            }
                            // Matches with "anysection"
                            //IParameterInfo info;
                            //if (part.ParameterName == "anysection" && ParameterInfos.Default.TryGetValue(parameter_name, out info) && info.IsSection) { next_parameter_ix = ix; break; }
                        }
                        // No matching parameter for this capture part
                        if (next_parameter_ix < 0)
                        {
                            continue;
                        }

                        // This part is canonical, hint, or parameter.
                        if (!next_parameter.IsNonCanonicalKey(parameterInfos))
                        {
                            // There (may be) are other canonical parts between part_ix and next_part_is. We have to add them here.
                            for (int ix = 0; ix < next_parameter_ix; ix++)
                            {
                                // Copy
                                ILineParameter parameter = parameters[ix];
                                // Has been added before
                                if ((parameter.ParameterName == null) || parameter.IsNonCanonicalKey(parameterInfos))
                                {
                                    continue;
                                }
                                // Append to level's key
                                levelKey = LineAppender.NonResolving.Create(levelKey, LineArgument.ToArgument(parameter));
                                // Mark handled
                                parameters[ix] = unused;
                            }
                        }
                        // Append to level's key
                        levelKey = LineAppender.NonResolving.Create(levelKey, LineArgument.ToArgument(next_parameter));
                        // Mark handled
                        parameters[next_parameter_ix] = unused;
                        // Yield level
                        if (part.PostfixSeparator.Contains("/"))
                        {
                            key_levels.Add(levelKey); levelKey = null;
                        }
                    }
                }

                // Append rest of the parameters
                for (int ix = 0; ix < parameters.Count; ix++)
                {
                    // Copy
                    ILineParameter parameter = parameters[ix];
                    if (parameter.ParameterName != null && parameter.ParameterName != "String")
                    {
                        levelKey = LineAppender.NonResolving.Create(levelKey, LineArgument.ToArgument(parameter));
                    }
                }

                // yield levelKey
                if (levelKey != null)
                {
                    key_levels.Add(levelKey); levelKey = null;
                }

                // Yield line
                tree.AddRecursive(key_levels, line.GetString());
                key_levels.Clear();
                parameters.Clear();
            }

            return(tree);
        }
 /// <summary>
 /// Construct new match.
 /// </summary>
 /// <param name="pattern"></param>
 public LinePatternMatch(ILinePattern pattern)
 {
     this.Pattern    = pattern;
     this.PartValues = new string[pattern.CaptureParts.Length];
 }
Exemplo n.º 13
0
        /// <summary>
        /// Build regex pattern that captures same parts from filename string.
        ///
        /// For example "localization{-Culture}.ini" translates to regex "localization(-(?&lt;Culture&gt;.*))?.ini".
        /// This can be matched against filename "localization-en.ini" with group m.Group["Culture"].Value == "en".
        /// </summary>
        /// <paramref name="pattern"/>
        /// <paramref name="filledParameters"/>>
        /// <returns>regex</returns>
        public static string BuildRegexString(this ILinePattern pattern, IReadOnlyDictionary <string, string> filledParameters, BuildRegexFlags flags = BuildRegexFlags.All)
        {
            StringBuilder sb = new StringBuilder();

            sb.Append('^');
            for (int i = 0; i < pattern.AllParts.Length; i++)
            {
                ILinePatternPart part = pattern.AllParts[i];

                // Add regular part
                if (part.Text != null)
                {
                    sb.Append(Escape(part.Text, flags, BuildRegexFlags.Escape_NonPart)); continue;
                }

                string prefilled_value;
                if (filledParameters != null && filledParameters.TryGetValue(part.Identifier, out prefilled_value) && prefilled_value != null)
                {
                    if (part.PrefixSeparator != null)
                    {
                        sb.Append(Escape(part.PrefixSeparator, flags, BuildRegexFlags.Escape_Prefix));
                    }
                    sb.Append(Escape(prefilled_value, flags, BuildRegexFlags.Escape_Identifier));
                    if (part.PostfixSeparator != null)
                    {
                        sb.Append(Escape(part.PostfixSeparator, flags, BuildRegexFlags.Escape_Postfix));
                    }
                }
                else
                {
                    sb.Append("(");
                    if (part.PrefixSeparator != null)
                    {
                        sb.Append(Escape(part.PrefixSeparator, flags, BuildRegexFlags.Escape_Prefix));
                    }
                    sb.Append("(?<");
                    sb.Append(Escape(part.Identifier, flags, BuildRegexFlags.Escape_Identifier));
                    sb.Append('>');
                    // Append type specific pattern
                    Regex  part_pattern = part.Regex;
                    string pattern_text = part_pattern.ToString();
                    int    start = 0, end = pattern_text.Length;
                    if (pattern_text.Length > 0 && pattern_text[start] == '^')
                    {
                        start++;
                    }
                    if (pattern_text.Length > 0 && pattern_text[end - 1] == '$')
                    {
                        end--;
                    }
                    if (start < end)
                    {
                        sb.Append(pattern_text.Substring(start, end - start));
                    }
                    sb.Append(')');
                    if (part.PostfixSeparator != null)
                    {
                        sb.Append(Escape(part.PostfixSeparator, flags, BuildRegexFlags.Escape_Postfix));
                    }
                    sb.Append(")");
                    if (!part.Required)
                    {
                        sb.Append('?');
                    }
                }
            }
            sb.Append('$');

            return(sb.ToString());
        }
Exemplo n.º 14
0
        /// <summary>
        /// Builds name from captured part values.
        /// </summary>
        /// <param name="pattern"></param>
        /// <param name="partValues"></param>
        /// <returns>Built name, or null if one of the required parts were not found.</returns>
        public static string Print(this ILinePattern pattern, IEnumerable <string> partValues)
        {
            // Count chars
            int length = 0;
            IEnumerator <string> partValuesEtor = partValues.GetEnumerator();

            foreach (ILinePatternPart part in pattern.AllParts)
            {
                if (part.Text != null)
                {
                    length += part.Text.Length;
                }
                else
                {
                    if (!partValuesEtor.MoveNext())
                    {
                        return(null);
                    }
                    string value = partValuesEtor.Current;
                    if (value != null)
                    {
                        length += part.PrefixSeparator.Length + part.PostfixSeparator.Length + value.Length;
                    }
                }
            }

            // Put together string
            // .. without StringBuilder, there needs to be efficiencies since this may be called frequently.
            int ix = 0;

            char[] chars = new char[length];
            partValuesEtor.Reset();
            foreach (ILinePatternPart part in pattern.AllParts)
            {
                if (part.Text != null)
                {
                    part.Text.CopyTo(0, chars, ix, part.Text.Length); ix += part.Text.Length;
                }
                else
                {
                    if (!partValuesEtor.MoveNext())
                    {
                        return(null);
                    }
                    string value = partValuesEtor.Current;
                    if (value == null)
                    {
                        if (part.Required)
                        {
                            return(null);
                        }
                        else
                        {
                            continue;
                        }
                    }
                    part.PrefixSeparator.CopyTo(0, chars, ix, part.PrefixSeparator.Length); ix += part.PrefixSeparator.Length;
                    value.CopyTo(0, chars, ix, value.Length); ix += value.Length;
                    part.PostfixSeparator.CopyTo(0, chars, ix, part.PostfixSeparator.Length); ix += part.PostfixSeparator.Length;
                }
            }
            return(new string(chars));
        }
Exemplo n.º 15
0
        /// <summary>
        /// Match parameters of an object and convert into a string.
        /// </summary>
        /// <param name="pattern"></param>
        /// <param name="key"></param>
        /// <returns>match as string or null</returns>
        public static string MatchToString(this ILinePattern pattern, ILine key)
        {
            ILinePatternMatch match = pattern.Match(key);

            return(pattern.Print(match.PartValues));
        }
Exemplo n.º 16
0
 /// <summary>
 /// Create abstract file source.
 /// </summary>
 /// <param name="fileFormat"></param>
 /// <param name="path"></param>
 /// <param name="filePattern"></param>
 /// <param name="lineFormat"></param>
 public LineFilePatternSource(ILineFileFormat fileFormat, string path, ILinePattern filePattern, ILineFormat lineFormat) : base(path, filePattern)
 {
     this.FileFormat = fileFormat ?? throw new ArgumentNullException(nameof(fileFormat));
     this.LineFormat = lineFormat;
 }
 /// <summary>
 /// Create comparer to <paramref name="pattern"/>.
 /// </summary>
 /// <param name="pattern"></param>
 public LinePatternMatchComparer(ILinePattern pattern)
 {
     this.Pattern = pattern ?? throw new ArgumentNullException(nameof(pattern));
 }
Exemplo n.º 18
0
 /// <summary>
 /// Create abstract file source.
 /// </summary>
 /// <param name="assembly"></param>
 /// <param name="resourcePattern"></param>
 public EmbeddedPatternSource(Assembly assembly, ILinePattern resourcePattern)
 {
     this.Assembly        = assembly ?? throw new ArgumentNullException(nameof(assembly));
     this.ResourcePattern = resourcePattern ?? throw new ArgumentNullException(nameof(resourcePattern));
 }