The Lounge - CodeProject

Re: Regular Expression - Achievement unlocked

Marco Bertschi5-Feb-14 20:17

Marco Bertschi

5-Feb-14 20:17

Where is the :Exorcism: Emoticon? WTF | :WTF:

Clean-up crew needed, grammar spill... - Nagy Vilmos

Re: Regular Expression - Achievement unlocked

JimmyRopes5-Feb-14 16:29

JimmyRopes

5-Feb-14 16:29

Welcome to the dark side. Suspicious | :suss:

The report of my death was an exaggeration - Mark Twain

Simply Elegant Designs JimmyRopes Designs
Think inside the box! ProActive Secure Systems

I'm on-line therefore I am.
JimmyRopes

Re: Regular Expression - Achievement unlocked

BillWoodruff5-Feb-14 17:38

BillWoodruff

5-Feb-14 17:38

Congratulations, Marco; I believe learning, and mastering, something new is one of the very best things in life !

It would be interesting to debate (perhaps on the C# forum ?) the short- and long- range cost/benefits of implementing a complex mini-parser like this using RegEx vs. "brute-force" string parsing, where "cost/benefits" would be looked at from different perspectives: say, from the perspective of a manager of programmers vs. a front-line programmer's perspective.

Of course the question of "constraints" immediately arises: what makes parsing the range of inputs you show more difficult is:

1. possible ambiguity of the "-" glyph: it is a separator for the Date component, and a sign-indicator for the time-offset.

2. possible ambiguity of the "." glyph: it is a presence/absence indicator for milliseconds, and a decimal-point for the time-offset.

If, you, the creator, have control over all possible inputs, and can ensure there will always something like ".0Z" indicating no milliseconds, and there will always be some other character than "-" separating year, month, day, then, obviously parsing becomes so much more simple.

However, maybe "control" is an academic issue here because the standard you are coding to allows such latitude in input format; I don't know anything about the RFC you are using.

As an experiment, I timed how long it took me to create a non-RegEx solution to parsing your sample data: about thirty minutes (code on request).

Since this was done early AM my time (GMT +07), and I was not fully caffeinated, perhaps I could have done this in twenty minutes, or less, later in the day, or evening.

Anyone up for debate ?

“But I don't want to go among mad people,” Alice remarked.

“Oh, you can't help that,” said the Cat: “we're all mad here. I'm mad. You're mad.”

“How do you know I'm mad?” said Alice.

“You must be," said the Cat, or you wouldn't have come here.” Lewis Carroll

Re: Regular Expression - Achievement unlocked

JimmyRopes5-Feb-14 18:14

JimmyRopes

5-Feb-14 18:14

BillWoodruff wrote:
(code on request)

Codes Plz

so I can do my homework assignment.

The report of my death was an exaggeration - Mark Twain

Simply Elegant Designs JimmyRopes Designs
Think inside the box! ProActive Secure Systems

I'm on-line therefore I am.
JimmyRopes

Re: Regular Expression - Achievement unlocked

BillWoodruff5-Feb-14 19:46

BillWoodruff

5-Feb-14 19:46

JimmyRopes wrote:
Codes Plz

To hear is to obey, Master: [^] *

* plain-vanilla text file

Re: Regular Expression - Achievement unlocked

JimmyRopes6-Feb-14 2:12

JimmyRopes

6-Feb-14 2:12

Ahhhhhhhhh. Dead | X|

I knew I used RegEx for a reason.

I have been using RegEx since my first stint at Bell Laboratories in the late 1970's. If you couldn't "grep" you had no street cred.

Since then I have used RegEx on many platforms and in many languages. I don't even think about searching for patterns any other way.

I know people who despise RegEx but it is to their detrement. They will have to code and debug a lot of code to do any kind of complex pattern recognition when they could use a RegEx and be done with it.

As for the efficiency that will depend on whether the RegEx engine is context free NFA (Nondeterministic Finite Automaton) or context sensitive DFA (Deterministic Finite Automaton).

In general context free is slower at complex pattern recognition but much easier to implement. Unless your application is time critical you will not notice any serious delay in processing as a result of using RegEx and they are easier to implement and debug. That is why I use them wherever I need to parse data.

Just my opinion.

The report of my death was an exaggeration - Mark Twain

Simply Elegant Designs JimmyRopes Designs
Think inside the box! ProActive Secure Systems

I'm on-line therefore I am.
JimmyRopes

modified 6-Feb-14 22:10pm.

Re: Regular Expression - Achievement unlocked

Marco Bertschi5-Feb-14 20:14

Marco Bertschi

5-Feb-14 20:14

BillWoodruff wrote:
I believe learning, and mastering, something new is one of the very best things in life !

Learning is often strapped to pain, and effort.
Mastering the learnt stuff is joy!

BillWoodruff wrote:
Of course the question of "constraints" immediately arises: what makes parsing the range of inputs you show more difficult is:

1. possible ambiguity of the "-" glyph: it is a separator for the Date component, and a sign-indicator for the time-offset.

2. possible ambiguity of the "." glyph: it is a presence/absence indicator for milliseconds, and a decimal-point for the time-offset.

It's all specified like that. [-->]

BillWoodruff wrote:
If, you, the creator, have control over all possible inputs, and can ensure there will always something like ".0Z" indicating no milliseconds, and there will always be some other character than "-" separating year, month, day, then, obviously parsing becomes so much more simple.

I don't have any control over the formatting, I only know the constraints of the allowed values.
By the way, I wrote some unit tests to compare the performance between split and RegEx: A split does not providea measeruable performance improvement, compared to the Regular Expression. What I really like about the RegEx solutions that the parsing method becomes a lot shorter, and is therefore more readable (see the method public bool FromString(string dateTime) in the code sample below:

I wrote the following code so far:

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace Springlog.Com.Messaging
{
    /// &lt;summary&gt;
    /// Represents the Timestamp of a &lt;see cref="SyslogMessageHeader"/&gt;
    /// Author: Marco Bertschi, (C) 2014 Marco Bertschi
    /// &lt;/summary&gt;
    public class SyslogTimestamp
    {
        #region Properties
        /// &lt;summary&gt;
        /// Returns the count of the days for a specific month in a specific year.
        /// &lt;/summary&gt;
        /// &lt;param name="month"&gt;month  &lt;/param&gt;
        /// &lt;param name="year"&gt;year&lt;/param&gt;
        /// &lt;returns&gt;&lt;/returns&gt;
        static short GetDayMaxDaysOfMonth(int month, int year)
        {
            if (month != 2)
            {
                //  January       March         May           July          August        October        December        
                if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12)
                {
                    return 31;
                }
                else // April, June, September, November
                {
                    return 30;
                }
            }
            else //February
            {
                if (IsLeapYear(year))
                {
                    return 29;
                }
                return 28;
            }
        }
        /// &lt;summary&gt;
        /// Returns true if the argument is a leap year
        /// &lt;/summary&gt;
        /// &lt;param name="year"&gt;The year number to check&lt;/param&gt;
        /// &lt;returns&gt;&lt;/returns&gt;
        private static bool IsLeapYear(int year)
        {
            if (year % 4 == 0)
            {
                if (year % 100 == 0)
                {
                    if (year % 400 == 0)
                    {
                        return true;
                    }
                    return false;
                }
                return true;
            }
            return false;
        }

        /// &lt;summary&gt;
        /// The part of the Timestamp which represents the year.
        /// &lt;/summary&gt;
        int year;
        /// &lt;summary&gt;
        /// Gets the year part of the Timestamp.
        /// &lt;/summary&gt;
        public int Year
        {
            get { return year; }
        }
        /// &lt;summary&gt;
        /// The part of the Timestamp which represents the month.
        /// &lt;/summary&gt;
        int month;
        /// &lt;summary&gt;
        /// Gets the month part of the Timestamp.
        /// &lt;/summary&gt;
        public int Month
        {
            get { return month; }
        }
        /// &lt;summary&gt;
        /// The part of the Timestamp which represents the day of the month.
        /// &lt;/summary&gt;
        int dayOfMonth;
        /// &lt;summary&gt;
        /// Gets the days part of the Timestamp.
        /// &lt;/summary&gt;
        public int DayOfMonth
        {
            get { return dayOfMonth; }
        }
        /// &lt;summary&gt;
        /// The part of the Timestamp which represents the hours.
        /// &lt;/summary&gt;
        int hours;
        /// &lt;summary&gt;
        /// Gets the hours part of the Timestamp.
        /// &lt;/summary&gt;
        public int Hours
        {
            get { return hours; }
        }
        /// &lt;summary&gt;
        /// The part of the Timestamp which represents the minutes.
        /// &lt;/summary&gt;
        int minutes;
        /// &lt;summary&gt;
        /// Gets the minutes part of the Timestamp.
        /// &lt;/summary&gt;
        public int Minutes
        {
            get { return minutes; }
        }
        /// &lt;summary&gt;
        /// The part of the Timestamp which represents the seconds.
        /// &lt;/summary&gt;
        int seconds;
        /// &lt;summary&gt;
        /// Gets the seconds part of the Timestamp.
        /// &lt;/summary&gt;
        public int Seconds
        {
            get { return seconds; }
        }
        /// &lt;summary&gt;
        /// The part of the Timestamp which represents the year.
        /// &lt;/summary&gt;
        int miliseconds;
        /// &lt;summary&gt;
        /// Gets the milliseconds part of the Timestamp.
        /// &lt;/summary&gt;
        public int Miliseconds
        {
            get { return miliseconds; }
        }
        /// &lt;summary&gt;
        /// The offset from the UTC timezone
        /// &lt;/summary&gt;
        double utcOffset;
        /// &lt;summary&gt;
        /// Gets or sets the offset from the UTC timezone.
        /// &lt;/summary&gt;
        public double UtcOffset
        {
            get { return utcOffset; }
            set { utcOffset = value; }
        }
        #endregion

        public SyslogTimestamp()
        {
            Reset();
        }

        public SyslogTimestamp(string timestamp)
        {
            Reset();
            FromString(timestamp);
        }

        public SyslogTimestamp(DateTime timestamp)
        {
            Reset();
            FromDateTime(timestamp);
        }

        /// &lt;summary&gt;
        /// Resets all fields to their default values;
        /// &lt;/summary&gt;
        private void Reset()
        {
            miliseconds = 0;
            seconds = 0;
            minutes = 0;
            hours = 0;
            dayOfMonth = 0;
            month = 0;
            year = 0;
            utcOffset = 0;
        }

        /// &lt;summary&gt;
        /// Parses a string into a Syslog timestamp.
        /// &lt;/summary&gt;
        /// &lt;param name="dateTime"&gt;string which is going to be parsed&lt;/param&gt;
        /// &lt;returns&gt;true = success | false = invalid string&lt;/returns&gt;
        public bool FromString(string dateTime)
        {
            Reset();// All fields must be resetted - Otherwise the parsing will give a wrong value!
            Regex splitRegex = new Regex(@"([0-9]{4})-([1-9]|[1][0-2])-([0-2]?[0-9]|[3][0-1])[T]([0-1]?[0-9]|[2][0-3])[:]([0-5]?[0-9])[:]([0-5]?[0-9])?.?([0-9]{1,6})[Z]([+-][0-9][\.|,]?[0-9]?|[0-9]{2}?|[+-]?[0][1][0-2][\.]?[0-9]?|[0-9]{2}?)", RegexOptions.IgnoreCase);
            Match timestamp = splitRegex.Match(dateTime);

            if (timestamp.Groups.Count &gt; 1)
            {
                AddYears(Int32.Parse(timestamp.Groups[1].Value));
                AddMonths(Int32.Parse(timestamp.Groups[2].Value));
                AddDays(Int32.Parse(timestamp.Groups[3].Value));
                AddHours(Int32.Parse(timestamp.Groups[4].Value));
                AddMinutes(Int32.Parse(timestamp.Groups[5].Value));
                AddSeconds(Int32.Parse(timestamp.Groups[6].Value));
                AddMilliseconds(Int32.Parse(timestamp.Groups[7].Value));
                utcOffset = Double.Parse(timestamp.Groups[8].Value, CultureInfo.InvariantCulture);
                return true;
            }
            else
            {
                return false;
            }
        }
        /// &lt;summary&gt;
        /// Returns a fully formatted Syslog timestamp, as string.
        /// &lt;/summary&gt;
        /// &lt;returns&gt;Syslog timestamp, as string&lt;/returns&gt;
        public string ToFormattedString()
        {
            string timezonePreSign = "+";
            if (utcOffset &lt; 0)
            {
                timezonePreSign = "";
            }
            return string.Format("{0}-{1}-{2}T{3}:{4}:{5}.{6}Z{7}{8}", year, month, dayOfMonth, hours, minutes, seconds, miliseconds, timezonePreSign, utcOffset.ToString().Replace(',','.'));
        }

        public DateTime ToDateTime()
        {
            DateTimeKind dateTimeKind;
            if(utcOffset == 0)
            {
                dateTimeKind = DateTimeKind.Utc;
            }
            else
	        {
                dateTimeKind = DateTimeKind.Local;        
	        }
            return new DateTime(year, month, dayOfMonth, hours, minutes, seconds, miliseconds, dateTimeKind);
        }

        /// &lt;summary&gt;
        /// Overriden ToString() method - Displays the same as ToFormattedString().
        /// &lt;/summary&gt;
        /// &lt;returns&gt;&lt;/returns&gt;
        public override string ToString()
        {
            return this.ToFormattedString();
        }
        /// &lt;summary&gt;
        /// Parses a &lt;see cref="System.DateTime"/&gt; type to a &lt;see cref="SyslogTimestamp"/&gt;. It is assumed that the
        /// DateTime type must be converted to UTC if the second argument is left out.
        /// &lt;/summary&gt;
        /// &lt;remarks&gt;
        /// The FromDateTime method recognizes only the current daylight saving time adjustment rule for the local time zone. 
        /// As a result, it is guaranteed to accurately return the UTC offset of a local time only during the period in which the 
        /// latest adjustment rule is in effect. It may return inaccurate results if time is a historic date and time value 
        /// that was subject to a previous adjustment rule.
        /// &lt;/remarks&gt;
        /// &lt;param name="timestamp"&gt;The &lt;see cref="System.DateTime"/&gt; type which will be parsed&lt;/param&gt;
        public void FromDateTime(DateTime timestamp)
        {
            TimeSpan utcOffset = TimeZone.CurrentTimeZone.GetUtcOffset(timestamp);
            this.utcOffset = utcOffset.Hours + (utcOffset.Minutes / 100); 

            AddMilliseconds(timestamp.Millisecond);
            AddSeconds(timestamp.Second);
            AddMinutes(timestamp.Minute);
            AddHours(timestamp.Hour);
            AddDays(timestamp.Day);
            AddMonths(timestamp.Month);
            AddYears(timestamp.Year);
        }

        /// &lt;summary&gt;
        /// Adds a &lt;see cref="System.TimeSpan"/&gt; to the timestamp
        /// &lt;/summary&gt;
        /// &lt;param name="timeSpan"&gt;The time span which is added to the Timestamp&lt;/param&gt;
        public void Add(TimeSpan timeSpan)
        {
            AddMilliseconds(timeSpan.Milliseconds);
            AddSeconds(timeSpan.Seconds);
            AddMinutes(timeSpan.Minutes);
            AddHours(timeSpan.Hours);
            AddDays(timeSpan.Days);
        }
        /// &lt;summary&gt;
        /// Adds the passed millisecond value to the timestamp
        /// &lt;/summary&gt;
        /// &lt;param name="val"&gt;Added milliseconds&lt;/param&gt;
        public void AddMilliseconds(int val)
        {
            if (val + miliseconds &gt;= 1000)
            {
                AddSeconds( val / 1000);
                miliseconds = (val % 1000);
            }
            else
            {
                miliseconds += val;
            }
        }
        /// &lt;summary&gt;
        /// Adds the passed second value to the timestamp
        /// &lt;/summary&gt;
        /// &lt;param name="val"&gt;Added seconds&lt;/param&gt;
        private void AddSeconds(int val)
        {
            if (seconds + val &gt;= 60)
            {
                AddMinutes(val / 60);
                seconds = (val % 60);
            }
            else
            {
                seconds += val;
            }
        }
        /// &lt;summary&gt;
        /// Adds the passed minute value to the timestamp
        /// &lt;/summary&gt;
        /// &lt;param name="val"&gt;Added minutes&lt;/param&gt;
        private void AddMinutes(int val)
        {
            if (minutes + val &gt;= 60)
            {
                AddMinutes(val / 60);
                minutes = (val % 60);
            }
            else
            {
                minutes += val;
            }
        }
        /// &lt;summary&gt;
        /// Adds the passed hour value to the timestamp
        /// &lt;/summary&gt;
        /// &lt;param name="val"&gt;Added hours&lt;/param&gt;
        private void AddHours(int val)
        {
            if (hours + val &gt;= 24)
            {
                AddDays (val / 24);
                hours = (val % 24);
            }
            else
            {
                hours += val;
            }
        }
        /// &lt;summary&gt;
        /// Adds the passed days value to the timestamp
        /// &lt;/summary&gt;
        /// &lt;param name="val"&gt;Added days&lt;/param&gt;
        private void AddDays(int val)
        {
            short dayCount = GetDayMaxDaysOfMonth(month, year);
            if (dayOfMonth + val &gt; dayCount)
            {
                AddMonths(val / dayCount);
                dayOfMonth = (val % dayCount);
            }
            else
            {
                dayOfMonth += val;
            }
        }
        /// &lt;summary&gt;
        /// Adds the passed month value to the timestamp
        /// &lt;/summary&gt;
        /// &lt;param name="val"&gt;Added months&lt;/param&gt;
        private void AddMonths(int val)
        {
            if (month + val &gt; 12)
            {
                AddYears(val / 12);
                month = (val % 12);
            }
            else
            {
                month += val;
            }
        }
        /// &lt;summary&gt;
        /// Adds the passed value to the year part of the time stamp
        /// &lt;/summary&gt;
        /// &lt;param name="val"&gt;Years to be added&lt;/param&gt;
        private void AddYears(int val)
        {
            year += val;
        }

        /// &lt;summary&gt;
        /// Returns true if the the parameter matches this instance.
        /// &lt;/summary&gt;
        /// &lt;remarks&gt;
        /// See &lt;see cref="DoMatch"/&gt;
        /// &lt;/remarks&gt;
        /// &lt;param name="other"&gt;The parameter to compare&lt;/param&gt;
        /// &lt;returns&gt;true|false&lt;/returns&gt;
        public override bool Equals(object o)
        {
            if (o is SyslogTimestamp)
            {
                return DoMatch((SyslogTimestamp)o, this);
            }
            else
            {
                return false;
            }
        }
        /// &lt;summary&gt;
        /// Returns true if a &amp; b match, else false.
        /// &lt;/summary&gt;
        /// &lt;remarks&gt;
        /// Match criteria:
        /// (a.year == b.Year)
        /// &amp;&amp; (a.month == b.Month)
        /// &amp;&amp; (a.dayOfMonth == b.DayOfMonth)
        /// &amp;&amp; (a.hours == b.Hours)
        /// &amp;&amp; (a.minutes == b.Minutes)
        /// &amp;&amp; (a.seconds == b.Seconds)
        /// &amp;&amp; (a.miliseconds == b.Miliseconds)
        /// &amp;&amp; (a.utcOffset == b.UtcOffset);
        /// &lt;/remarks&gt;
        public static bool DoMatch(SyslogTimestamp a, SyslogTimestamp b)
        {
            bool doMatch = (a.year == b.Year)
                &amp;&amp; (a.month == b.Month)
                &amp;&amp; (a.dayOfMonth == b.DayOfMonth)
                &amp;&amp; (a.hours == b.Hours)
                &amp;&amp; (a.minutes == b.Minutes)
                &amp;&amp; (a.seconds == b.Seconds)
                &amp;&amp; (a.miliseconds == b.Miliseconds)
                &amp;&amp; (a.utcOffset == b.UtcOffset);

            return doMatch;
        }
        /// &lt;summary&gt;
        /// The overloaded == operator
        /// &lt;/summary&gt;
        /// &lt;remarks&gt;
        /// see http://msdn.microsoft.com/en-us/library/ms173147(v=vs.80).aspx
        /// &lt;/remarks&gt;
        public static bool operator ==(SyslogTimestamp a, SyslogTimestamp b)
        {
            // If both are null, or both are same instance, return true.
            if (System.Object.ReferenceEquals(a, b))
            {
                return true;
            }

            // If one is null, but not both, return false.
            if (((object)a == null) || ((object)b == null))
            {
                return false;
            }

            return DoMatch(a, b);
        }
        /// &lt;summary&gt;
        /// The overloaded != operator.
        /// &lt;/summary&gt;
        /// &lt;remarks&gt;
        /// see http://msdn.microsoft.com/en-us/library/ms173147(v=vs.80).aspx
        /// &lt;/remarks&gt;
        public static bool operator !=(SyslogTimestamp a, SyslogTimestamp b)
        {
            return !(a == b);
        }
        /// &lt;summary&gt;
        /// The smaller than Operator
        /// compares every date|time related field with
        /// the other and returns true if the left hand side of
        /// the assignement is smaller than the right hand side
        /// &lt;/summary&gt;
        /// &lt;param name="a"&gt;&lt;/param&gt;
        /// &lt;param name="b"&gt;&lt;/param&gt;
        /// &lt;returns&gt;&lt;/returns&gt;
        public static bool operator &lt;(SyslogTimestamp a, SyslogTimestamp b)
        {
            if (a.Year &lt; b.Year) { return true; }
            if (a.Year &gt; b.Year) { return false; }

            if (a.Month &lt; b.Month) { return true; }
            if (a.Month &gt; b.Month) { return false; }

            if (a.DayOfMonth &lt; b.DayOfMonth) { return true; }
            if (a.DayOfMonth &gt; b.DayOfMonth) { return false; }

            if ((a.Hours + a.UtcOffset) &lt; (b.Hours + b.UtcOffset)) { return true; }
            if ((a.Hours + a.UtcOffset) &gt; (b.Hours + b.UtcOffset)) { return false; }

            if (a.Minutes &lt; b.Minutes) { return true; }
            if (a.Minutes &gt; b.Minutes) { return false; }

            if (a.Seconds &lt; b.Seconds) { return true; }
            if (a.Seconds &gt; b.Seconds) { return false; }

            if (a.Miliseconds &lt; b.Miliseconds) { return true; }
            if (a.Miliseconds &gt; b.Miliseconds) { return false; }

            return false;
        }
        /// &lt;summary&gt;
        /// The greater than Operator
        /// compares every date|time related field with
        /// the other and returns true if the left hand side of
        /// the assignement is greater than the right hand side
        /// &lt;/summary&gt;
        /// &lt;param name="a"&gt;&lt;/param&gt;
        /// &lt;param name="b"&gt;&lt;/param&gt;
        /// &lt;returns&gt;&lt;/returns&gt;
        public static bool operator &gt;(SyslogTimestamp a, SyslogTimestamp b)
        {
            if (a.Year &gt; b.Year) { return true; }
            if (a.Year &lt; b.Year) { return false; }

            if (a.Month &gt; b.Month) { return true; }
            if (a.Month &lt; b.Month) { return false; }

            if (a.DayOfMonth &gt; b.DayOfMonth) { return true; }
            if (a.DayOfMonth &lt; b.DayOfMonth) { return false; }

            if ((a.Hours + a.UtcOffset) &gt; (b.Hours + b.UtcOffset)) { return true; }
            if ((a.Hours + a.UtcOffset) &lt; (b.Hours + b.UtcOffset)) { return false; }

            if (a.Minutes &gt; b.Minutes) { return true; }
            if (a.Minutes &lt; b.Minutes) { return false; }

            if (a.Seconds &gt; b.Seconds) { return true; }
            if (a.Seconds &lt; b.Seconds) { return false; }

            if (a.Miliseconds &gt; b.Miliseconds) { return true; }
            if (a.Miliseconds &lt; b.Miliseconds) { return false; }

            return false;
        }
        /// &lt;summary&gt;
        /// greater or equal Operator
        /// &lt;/summary&gt;
        /// &lt;param name="a"&gt;&lt;/param&gt;
        /// &lt;param name="b"&gt;&lt;/param&gt;
        /// &lt;returns&gt;(a &gt; b) || DoMatch(a, b)&lt;/returns&gt;
        public static bool operator &gt;=(SyslogTimestamp a, SyslogTimestamp b) 
        {
            return (a &gt; b) || DoMatch(a, b);
        }
        /// &lt;summary&gt;
        /// smaller or equal Operator
        /// &lt;/summary&gt;
        /// &lt;param name="a"&gt;&lt;/param&gt;
        /// &lt;param name="b"&gt;&lt;/param&gt;
        /// &lt;returns&gt;&lt;code&gt;(a { b) || DoMatch(a, b)&lt;/code&gt;&lt;/returns&gt;
        public static bool operator &lt;=(SyslogTimestamp a, SyslogTimestamp b)
        {
            return (a &lt; b) || DoMatch(a, b);
        }

        /// &lt;summary&gt;
        /// Returns the Hash code of the object
        /// &lt;/summary&gt;
        /// &lt;returns&gt;Hash code&lt;/returns&gt;
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }
}

Which is checked by the following Unit Tests:

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Springlog.Com.Messaging;

namespace Springlog.Com.Messaging.UnitTests
{
    [TestClass]
    public class SyslogTimestampUnitTest
    {
        /// &lt;summary&gt;
        /// This test case shall ensure that the compareing operators on the 
        /// SyslogTimestamp type are working correctly.
        /// &lt;/summary&gt;
        [TestMethod]
        public void SyslogTimestampComparisonIntegrity()
        {
            SyslogTimestamp timestamp1 = new SyslogTimestamp();
            SyslogTimestamp timestamp2 = new SyslogTimestamp();
            SyslogTimestamp timestamp3 = new SyslogTimestamp();
            SyslogTimestamp timestamp4 = new SyslogTimestamp();

            timestamp1.FromDateTime(DateTime.Now);
            timestamp2.FromDateTime(DateTime.Now.AddDays(-1));
            timestamp3 = timestamp1;
            timestamp4.FromDateTime(DateTime.Now.AddMinutes(2));

            Assert.AreEqual(true, (timestamp1 &gt; timestamp2));
            Assert.AreEqual(true, (timestamp4 &gt; timestamp1));
            Assert.AreEqual(false, (timestamp1 &lt; timestamp2));
            Assert.AreEqual(true, (timestamp1 &gt;= timestamp2));
            Assert.AreEqual(false, (timestamp1 &lt;= timestamp2));
            Assert.AreEqual(true, (timestamp1 == timestamp3));
            Assert.AreEqual(false, (timestamp1 != timestamp3));
            Assert.AreEqual(false, (timestamp1 == timestamp4));
            Assert.AreEqual(false, (timestamp1 == timestamp2));
        }

        /// &lt;summary&gt;
        /// This test case shall ensure that no errors are happening when 
        /// converting a string to a timestamp, and vice versa.
        /// &lt;/summary&gt;
        [TestMethod]
        public void SyslogTimestampStringConversionIntegrity()
        {
            DateTime now = DateTime.Now;
            SyslogTimestamp timestamp = new SyslogTimestamp();
            SyslogTimestamp timestamp2 = new SyslogTimestamp();

            timestamp.FromDateTime(now);

            timestamp.UtcOffset = 1;
            Assert.AreEqual(true, timestamp2.FromString(timestamp.ToFormattedString()));
            Assert.AreEqual(true, (timestamp2 == timestamp));

            timestamp.UtcOffset = 1.5;
            Assert.AreEqual(true, timestamp2.FromString(timestamp.ToFormattedString()));
            Assert.AreEqual(true, (timestamp2 == timestamp));
        }
        /// &lt;summary&gt;
        /// This test case shall ensure that no errors are happening when 
        /// converting a DateTime type to a timestamp, and vice versa.
        /// &lt;/summary&gt;
        [TestMethod]
        public void SyslogTimestampDateTimeConversionIntegrity()
        {
            DateTime now = DateTime.Now;
            SyslogTimestamp timestamp = new SyslogTimestamp();

            timestamp.FromDateTime(now);
            DateTime timestampDateTime = timestamp.ToDateTime();

            Assert.AreEqual(now.Year, timestampDateTime.Year);
            Assert.AreEqual(now.Month, timestampDateTime.Month);
            Assert.AreEqual(now.Day, timestampDateTime.Day);
            Assert.AreEqual(now.Hour, timestampDateTime.Hour);
            Assert.AreEqual(now.Minute, timestampDateTime.Minute);
            Assert.AreEqual(now.Second, timestampDateTime.Second);
            Assert.AreEqual(now.Millisecond, timestampDateTime.Millisecond);
        }
    }
}

Clean-up crew needed, grammar spill... - Nagy Vilmos

Re: Regular Expression - Achievement unlocked

BillWoodruff5-Feb-14 21:20

BillWoodruff

5-Feb-14 21:20

Hi Marco,

I'm enjoying reading your novel-in-code Smile | :)

, and I looked at the RFC5424 spec which I consider brain-damaged.

I note that use of "Z" is optional, so that would mean my little flirtation with parsing your data would have to be rejiggered.

What were the authors of that spec thinking when they allowed ambiguous characters that have varying meanings depending on position ?

You'd also think that specs like this would provide a reference parser implementation in pseudo-code, or some computer language; however, for all I know, there is a reference implementation somewhere.

cheers, Bill

Re: Regular Expression - Achievement unlocked

Marco Bertschi5-Feb-14 21:24

Marco Bertschi

5-Feb-14 21:24

BillWoodruff wrote:
and I looked at the RFC5424 spec which I consider brain-damaged.

Not at all - The timestamp may be completly brain-damaged, but at least it is clearly specified.

BillWoodruff wrote:
I note that use of "Z" is optional, so that would mean my little flirtation with parsing your data would have to be rejiggered.

That's in fact brain-damaged.

BillWoodruff wrote:
What were the authors of that spec thinking when they allowed ambiguous characters that have varying meanings depending on position ?

As far as I can recall, the spec was written by Rainer Gerhards as the only author.
Which explains the complexity, that guy makes a fortune doing consulting for it (at least I suspect it).

BillWoodruff wrote:
You'd also think that specs like this would provide a reference parser implementation in pseudo-code, or some computer language; however, for all I know, there is a reference implementation somewhere.

Not if the author can make consultant money from it.

Clean-up crew needed, grammar spill... - Nagy Vilmos

Re: Regular Expression - Achievement unlocked

Steve Wellens5-Feb-14 17:51

Steve Wellens

5-Feb-14 17:51

([0-9]{4})-([1-9]|[1][0-2])-([0-2]?[0-9]|[3][0-1])[T]([0-1]?[0-9]|[2][0-3])[:]([0-5]?[0-9])[:]([0-5]?[0-9])?.?([0-9]{1,6})[Z]([+-][0-9][\.|,]?[0-9]?|[0-9]{2}?|[+-]?[0][1][0-2][\.]?[0-9]?|[0-9]{2}?)

Steve Wellens

Re: Regular Expression - Achievement unlocked

Septimus Hedgehog5-Feb-14 21:29

Septimus Hedgehog

5-Feb-14 21:29

Marco, OriginalGriff and I recommend Expresso. You might want to add RegexBulder[^] as well to your regex toolbox. RegexBuilder lets you try your expression on multiple input strings which makes it very useful for testing your expression.

If there is one thing more dangerous than getting between a bear and her cubs it's getting between my wife and her chocolate.

Re: Regular Expression - Achievement unlocked

Rage5-Feb-14 22:12

Rage

5-Feb-14 22:12

Marco Bertschi wrote:
(I have tried to avoid them, but I eventually got that they are absolutely inavoidable, especially when it comes to ~~parsing complex strings)~~ be the coolest boy in the sandbox.

~RaGE();

I think words like 'destiny' are a way of trying to find order where none exists. - Christian Graus
Do not feed the troll ! - Common proverb

Re: Regular Expression - Achievement unlocked

Fabio Franco5-Feb-14 23:02

Fabio Franco

5-Feb-14 23:02

Marco Bertschi wrote:
And that's the string it will parse: 2014-2-5T21:36:14.315Z+1.5

You didn't need to tell us what it will parse, it's immediatelly obvious what the regex is for. Anyone can see that.

To alcohol! The cause of, and solution to, all of life's problems - Homer Simpson
----
Our heads are round so our thoughts can change direction - Francis Picabia

Re: Regular Expression - Achievement unlocked

Thornik6-Feb-14 0:24

Thornik

6-Feb-14 0:24

Nothing beautiful, looks like a dump. [0-9] is just a \d.

Re: Regular Expression - Achievement unlocked

svella6-Feb-14 3:17

svella

6-Feb-14 3:17

You could simplify/shorten it by replacing each instance of [0-9] with \d and getting rid of [] around single characters, though I suppose that could make it less readable.

Re: Regular Expression - Achievement unlocked

Marco Bertschi6-Feb-14 3:29

Marco Bertschi

6-Feb-14 3:29

I already have improved it, with the help of OG:
http://www.codeproject.com/Messages/4752996/Re-RegEx-problem-sharp2.aspx[^]

Clean-up crew needed, grammar spill... - Nagy Vilmos

Re: Regular Expression - Achievement unlocked

TheFigmo6-Feb-14 4:34

TheFigmo

6-Feb-14 4:34

I have managed to avoid this convoluted mess for over 30 years. And with a little luck, when i die i will STILL not speak regex.

.net string methods work just fine for me. About as fast for 90% of your needs and more readable for 100% of your needs.

The 2 or 3 times i have actually needed the power of regex in 30 years, i just sub'd out that line of code. And rather than learning/debugging/banging head .... I went to the beach swilling cheap whiskey and chasing cheaper women.

My advice to those who dont yet know regex....impress your peers with cheap whiskey and women and forget about the regex. Both make your head hurt....but one is less fun.....

Re: Regular Expression - Achievement unlocked

Marco Bertschi6-Feb-14 4:37

Marco Bertschi

6-Feb-14 4:37

I didn't found RegEx to be too hard, after finding out the basic principles at least. It's the same as with every new thing: Learning by doing!

Clean-up crew needed, grammar spill... - Nagy Vilmos

Re: Regular Expression - Achievement unlocked

syspau6-Feb-14 7:52

syspau

6-Feb-14 7:52

I think this site is the best tutorial/guide to regular expressions:

http://www.regular-expressions.info/tutorial.html

Clear descriptions of everything from simple to complex.

---

I like this site for testing expressions:

http://www.regexr.com/

It's an online testing tool (plus a downloadable version if you like). Paste in your expression, paste in your text, see where it matches, with analysis, hover over matches to see groups.

Re: Regular Expression - Achievement unlocked

Ralph Little6-Feb-14 7:56

Ralph Little

6-Feb-14 7:56

You can probably compress it a little. If you are matching a single character, then you don't need []:

[0] => 0
[:] => :
[0][1][0-2][\.]? => 01[0-2]\.?

.? I think needs to be quoted where you mean ".": . => \.?

Also, you can often use meta characters to save some finger work:

[0-9] => \d
[0-9]{4} => \d{4}

Also, some of the expressions don't need to be bracketed:

([0-9]{4}) => \d{4}
You only need the brackets if you want the parser to be able to treat it as a unit in larger ops.

Just some ideas. Nice work though!

Re: Regular Expression - Achievement unlocked

dpminusa6-Feb-14 22:37

dpminusa

6-Feb-14 22:37

One approach I have used with varying levels of utility is to treat the regex pattern like an algebraic expression. Factor out common terms and assign them to variables. Use replication counts, etc. This can simplify the final result and make it more maintainable.

Your pattern can be simplified a bit and made more readable somewhat by this. I found other strings like valid IP addresses can be greatly simplified this way.

Maybe this is useful to you!?

"Courtesy is the product of a mature, disciplined mind ... ridicule is lack of the same - DPM"

Visual Studio with MSDN Premium

Joel Palmer5-Feb-14 7:41

Joel Palmer

5-Feb-14 7:41

Has any looked at the MSDN pricing lately?

I do some MS Office (excel) integration for my customers so it requires that I get their version of MS Office (all the versions; 97 to 2013) to program against. To have access to Office I need to upgrade from the MSDN Pro to MSDN Premium... which costs $5000 more!

Can anyone explain to me how they can justify charging developers $5000 to integrate with their products? I'm not writing the president's speeches using these installs. I'm writing software so my customers will continue to use MS products and purchase licenses.

Cry | :((