FilePattern.cs

Go to the documentation of this file.

using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Xml.Serialization;

namespace DirectOutput.GlobalConfiguration
{
    public class FilePattern : INotifyPropertyChanged, IXmlSerializable
    {


        #region IXmlSerializable Member




        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null;
        }

        public void ReadXml(System.Xml.XmlReader reader)
        {
            Pattern = reader.ReadString();
            if (!reader.IsEmptyElement)
            {
                reader.ReadEndElement();
            }
            else
            {
                reader.ReadStartElement();
            }
        }

        public void WriteXml(System.Xml.XmlWriter writer)
        {
            writer.WriteString(Pattern);
        }

        #endregion

        #region INotifyPropertyChanged Member

        public event PropertyChangedEventHandler PropertyChanged;

        private void NotifyPropertyChanged(string PropertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(PropertyName));
            }
        }

        #endregion

        private string _Pattern;

        public string Pattern
        {
            get { return _Pattern; }
            set
            {
                if (_Pattern != value)
                {
                    _Pattern = value;
                    NotifyPropertyChanged("Pattern");
                }
            }
        }

        public string ReplacePlaceholders(Dictionary<string, string> ReplaceValues = null)
        {
            string P = Pattern;
            if (ReplaceValues != null)
            {
                foreach (KeyValuePair<string, string> KV in ReplaceValues)
                {
                    P = P.Replace("{" + (KV.Key) + "}", KV.Value);
                }
            }
            return P;
        }


        public List<FileInfo> GetMatchingFiles(Dictionary<string, string> ReplaceValues = null)
        {
            if (Pattern.IsNullOrWhiteSpace()) return new List<FileInfo>();

            string P = ReplacePlaceholders(ReplaceValues);

            try
            {

                DirectoryInfo FilesDirectory = new DirectoryInfo((Path.GetDirectoryName(P).IsNullOrWhiteSpace() ? "." : Path.GetDirectoryName(P)));
                if (FilesDirectory.Exists)
                {
                    return FilesDirectory.GetFiles(Path.GetFileName(P)).ToList<FileInfo>();
                }
                else
                {
                    return new List<FileInfo>();
                }
            }
            catch
            {
                return new List<FileInfo>();
            }
        }

        public FileInfo GetFirstMatchingFile(Dictionary<string, string> ReplaceValues = null)
        {
            List<FileInfo> L = GetMatchingFiles(ReplaceValues);
            if (L.Count > 0)
            {
                return L[0];
            }
            else
            {
                return null;
            }
        }


        public bool IsValid
        {
            get
            {
                if (Pattern.IsNullOrWhiteSpace()) return true;

                try
                {
                    FileInfo DummyFileInfo = new FileInfo(Pattern.Replace("*", "test").Replace("?", "X"));
                }
                catch
                {
                    return false;
                }

                bool BracketOpen = false;
                bool JustOpend = false;
                foreach (char C in Pattern)
                {
                    switch (C)
                    {
                        case '{':
                            if (BracketOpen) return false;
                            BracketOpen = true;
                            JustOpend = true;
                            break;
                        case '}':
                            if (!BracketOpen) return false;
                            if (JustOpend) return false;
                            BracketOpen = false;
                            JustOpend = false;
                            break;
                        case '\\':
                        case '*':
                        case '?':
                            if (BracketOpen) return false;
                            JustOpend = false;
                            break;
                        default:
                            JustOpend = false;
                            break;
                    }
                }
                if (BracketOpen) return false;
                return true;
            }
        }


        public FilePattern(string Pattern)
        {
            if (Pattern != null)
            {
                this.Pattern = Pattern;
            }

        }

        public override string ToString()
        {
            return Pattern;
        }


        public FilePattern()
        {

        }


    }
}