public void ProcessEvent(IDEEvent @event)
        {
            if (@event.ActiveDocument != null && _currentIntervals.ContainsKey(@event.ActiveDocument))
            {
                _context.AdaptIntervalTimeData(_currentIntervals[@event.ActiveDocument], @event);
            }

            var documentEvent = @event as DocumentEvent;

            if (documentEvent != null && documentEvent.Document != null)
            {
                if (_currentIntervals.ContainsKey(documentEvent.Document))
                {
                    _context.AdaptIntervalTimeData(_currentIntervals[documentEvent.Document], @event);

                    if (documentEvent.Action == DocumentAction.Closing)
                    {
                        _intervals.Add(_currentIntervals[documentEvent.Document]);
                        _currentIntervals.Remove(documentEvent.Document);
                    }
                }
                else
                {
                    if (documentEvent.Action == DocumentAction.Opened)
                    {
                        _currentIntervals[documentEvent.Document] =
                            _context.CreateIntervalFromEvent <FileOpenInterval>(@event);
                        _currentIntervals[documentEvent.Document].FileName = documentEvent.Document.FileName;
                    }
                }
            }
        }
 public void ProcessEvent(IDEEvent e)
 {
     if (_intervals.ContainsKey(e.IDESessionUUID))
     {
         _context.AdaptIntervalTimeData(_intervals[e.IDESessionUUID], e);
     }
     else
     {
         _intervals.Add(
             e.IDESessionUUID,
             _context.CreateIntervalFromEvent <VisualStudioOpenedInterval>(e));
     }
 }
        public void ProcessEvent(IDEEvent @event)
        {
            if (_currentInterval != null &&
                _currentInterval.Perspective == PerspectiveType.Production &&
                MarksStartOfDebugSession(@event))
            {
                _currentInterval = null;
            }

            if (_currentInterval == null)
            {
                _currentInterval = _context.CreateIntervalFromEvent <PerspectiveInterval>(@event);

                if (_currentInterval.StartTime < _referenceTime)
                {
                    _currentInterval.Duration -= _referenceTime - _currentInterval.StartTime;
                    _currentInterval.StartTime = _referenceTime;
                }

                _intervals.Add(_currentInterval);

                _currentInterval.Perspective = MarksStartOfDebugSession(@event)
                    ? PerspectiveType.Debug
                    : PerspectiveType.Production;
            }
            else
            {
                _context.AdaptIntervalTimeData(_currentInterval, @event);
                _referenceTime = @event.TerminatedAt.GetValueOrDefault();

                if (MarksEndOfDebugSession(@event))
                {
                    _currentInterval = null;
                }
            }
        }