예제 #1
0
 public UltraTime()
 {
     TimeSpan       = LogWatch.Elapsed;
     DateTime       = DateTime.UtcNow;
     AtomicDateTime = TimeStamp.CurrentDateTime;
     Jitter         = LogWatch.Elapsed - TimeSpan;
     Inputs         = new byte[5];
 }
예제 #2
0
        public static Attempt ParseXml(XmlElement node)
        {
            var            newTime       = Time.FromXml(node);
            var            index         = int.Parse(node.Attributes["id"].InnerText, CultureInfo.InvariantCulture);
            AtomicDateTime?started       = null;
            var            startedSynced = false;
            AtomicDateTime?ended         = null;
            var            endedSynced   = false;

            if (node.HasAttribute("started"))
            {
                var startedTime = DateTime.Parse(node.Attributes["started"].InnerText, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal);
                if (node.HasAttribute("isStartedSynced"))
                {
                    startedSynced = bool.Parse(node.Attributes["isStartedSynced"].InnerText);
                }
                started = new AtomicDateTime(startedTime, startedSynced);
            }

            if (node.HasAttribute("ended"))
            {
                var endedTime = DateTime.Parse(node.Attributes["ended"].InnerText, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal);
                if (node.HasAttribute("isEndedSynced"))
                {
                    endedSynced = bool.Parse(node.Attributes["isEndedSynced"].InnerText);
                }
                ended = new AtomicDateTime(endedTime, endedSynced);
            }

            TimeSpan?pauseTime = null;

            if (node.GetElementsByTagName("PauseTime").Count > 0)
            {
                TimeSpan x;
                if (TimeSpan.TryParse(node["PauseTime"].InnerText, out x))
                {
                    pauseTime = x;
                }
            }

            return(new Attempt(index, newTime, started, ended, pauseTime));
        }
예제 #3
0
        public void AtomicityDateTime()
        {
            var currentDate = DateTime.Now;

            AtomicTypeBase <DateTime> atomic = new AtomicDateTime(currentDate);

            void ToggleValueTask()
            {
                for (var x = 0; x < 10; x++)
                {
                    atomic++;
                }
            }

            Task.WaitAll(
                Task.Run(ToggleValueTask),
                Task.Run(ToggleValueTask),
                Task.Run(ToggleValueTask));

            var expected = currentDate.AddTicks(30).Date;

            Assert.That(atomic.Value.Date == expected);
        }
예제 #4
0
        private void parseHistory(IRun run)
        {
            try
            {
                if (!string.IsNullOrEmpty(Path))
                {
                    var path = System.IO.Path.Combine(
                        System.IO.Path.GetDirectoryName(Path),
                        string.Format("{0}-RunLog.txt",
                                      System.IO.Path.GetFileNameWithoutExtension(Path)));

                    var lines     = File.ReadLines(path);
                    var attemptId = 1;

                    foreach (var line in lines.Skip(1))
                    {
                        var segmentInfo     = line.Split('\t');
                        var timeStampString = segmentInfo[0];
                        var completed       = segmentInfo[1] == "C";
                        var splits          = segmentInfo.Skip(2).Select(x => parseTimeNullable(x)).ToList();

                        var            started   = DateTime.Parse(timeStampString, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal);
                        Time           finalTime = default(Time);
                        AtomicDateTime?ended     = null;
                        if (completed)
                        {
                            finalTime.RealTime = splits.Last().Value;
                            var finalDate = started + finalTime.RealTime;
                            if (finalDate.HasValue)
                            {
                                ended = new AtomicDateTime(finalDate.Value, false);
                            }
                        }

                        run.AttemptHistory.Add(new Attempt(attemptId, finalTime, new AtomicDateTime(started, false), ended));

                        var      i         = 0;
                        TimeSpan?lastSplit = TimeSpan.Zero;
                        foreach (var segment in run)
                        {
                            if (splits.Count <= i)
                            {
                                break;
                            }

                            var  currentSplit = splits[i];
                            Time segmentTime  = default(Time);
                            if (currentSplit.HasValue)
                            {
                                segmentTime.RealTime = currentSplit - lastSplit;
                                lastSplit            = currentSplit;
                            }

                            segment.SegmentHistory.Add(attemptId, segmentTime);
                            if (segmentTime.RealTime < segment.BestSegmentTime.RealTime)
                            {
                                segment.BestSegmentTime = segmentTime;
                            }
                            i++;
                        }

                        attemptId++;
                    }
                }
            }
            catch { }
        }
        private void parseHistory(IRun run)
        {
            try
            {
                if (!string.IsNullOrEmpty(Path))
                {
                    var path = System.IO.Path.Combine(
                                System.IO.Path.GetDirectoryName(Path), 
                                string.Format("{0}-RunLog.txt", 
                                    System.IO.Path.GetFileNameWithoutExtension(Path)));

                    var lines = File.ReadLines(path);
                    var attemptId = 1;

                    foreach (var line in lines.Skip(1))
                    {
                        var segmentInfo = line.Split('\t');
                        var timeStampString = segmentInfo[0];
                        var completed = segmentInfo[1] == "C";
                        var splits = segmentInfo.Skip(2).Select(x => parseTimeNullable(x)).ToList();

                        var started = DateTime.Parse(timeStampString, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal);
                        Time finalTime = default(Time);
                        AtomicDateTime? ended = null;
                        if (completed)
                        {
                            finalTime.RealTime = splits.Last().Value;
                            var finalDate = started + finalTime.RealTime;
                            if (finalDate.HasValue)
                                ended = new AtomicDateTime(finalDate.Value, false);
                        }

                        run.AttemptHistory.Add(new Attempt(attemptId, finalTime, new AtomicDateTime(started, false), ended));

                        var i = 0;
                        TimeSpan? lastSplit = TimeSpan.Zero;
                        foreach (var segment in run)
                        {
                            if (splits.Count <= i)
                                break;

                            var currentSplit = splits[i];
                            Time segmentTime = default(Time);
                            if (currentSplit.HasValue)
                            {
                                segmentTime.RealTime = currentSplit - lastSplit;
                                lastSplit = currentSplit;
                            }

                            segment.SegmentHistory.Add(attemptId, segmentTime);
                            if (segmentTime.RealTime < segment.BestSegmentTime.RealTime)
                                segment.BestSegmentTime = segmentTime;
                            i++;
                        }

                        attemptId++;
                    }
                }
            }
            catch { }
        }