public CodeError(ErrorType Type, ErrorLevel Level, CodeLine Line, string Remarks = "")
 {
     this.Type = Type;
     this.Level = Level;
     this.Line = Line;
     this.Remarks = Remarks;
 }

 public XmlValidationError(ErrorLevel errorLevel, XmlErrorType errorType, string message, int? lineNumber = null)
 {
     ErrorLevel = errorLevel;
     ErrorType = errorType;
     Message = message;
     LineNumber = lineNumber;
 }

 public DataReturnUploadError(ErrorLevel errorLevel, UploadErrorType errorType, string description, int lineNumber = 0)
 {
     ErrorType = errorType;
     ErrorLevel = errorLevel;
     Description = description;
     LineNumber = lineNumber;
 }

 internal DaqException(string errorMessage, ErrorCodes errorCode)
     : base(errorMessage)
 {
     m_errorCode = errorCode;
     m_level = ErrorLevel.Error;
     m_lastResponse = null;
 }

 /// <summary>
 ///     Запись в лог
 /// </summary>
 /// <param name="logLevel">Уровень</param>
 /// <param name="message">Текст записи</param>
 /// <param name="exception">Исключение</param>
 public LogEntry(ErrorLevel logLevel, string message, Exception exception)
     : this()
 {
     Level = logLevel;
     Message = message;
     Exception = exception;
 }

 public LogEntry(DateTime errorDateTime, ErrorLevel errorLevel, string tag,string message)
 {
     this.errorDateTime = errorDateTime;
     this.errorLevel = errorLevel;
     this.tag = tag;
     this.message = message;
 }

		public void Handle(Exception exception, ErrorLevel errorLevel) {
			if (exception is WrappedException)
				_reportAnyManagedExceptions(exception.Message, ((WrappedException) exception).Exception, errorLevel);
			else
				_reportAnyManagedExceptions(exception.Message, exception, errorLevel);

			if (errorLevel < SdeAppConfiguration.WarningLevel) return;

			if (_exceptionAlreadyShown(exception.Message)) return;

			if (Application.Current != null) {
				_checkMainWindow();

				if (IgnoreNoMainWindow) {
					WindowProvider.ShowWindow(new ErrorDialog("Information", _getHeader(errorLevel) + exception.Message, errorLevel), WpfUtilities.TopWindow);
				}
				else {
					if (!Application.Current.Dispatch(() => Application.Current.MainWindow != null && Application.Current.MainWindow.IsLoaded)) {
						_showBasicError(_getHeader(errorLevel) + exception.Message, "Information");
						return;
					}

					Application.Current.Dispatch(() => WindowProvider.ShowWindow(new ErrorDialog("Information", _getHeader(errorLevel) + exception.Message, errorLevel), Application.Current.MainWindow));
				}
			}
		}

		/// <summary>
		/// Creates a new reader
		/// </summary>
		/// <param name="stream"></param>
		/// <param name="errorLevel"></param>
		public FbxAsciiReader(Stream stream, ErrorLevel errorLevel = ErrorLevel.Checked)
		{
			if(stream == null)
				throw new ArgumentNullException(nameof(stream));
			this.stream = stream;
			this.errorLevel = errorLevel;
		}

 public LanguageError(string file, string key, string message, ErrorLevel level = ErrorLevel.MissingString)
 {
     File = file;
     Key = key;
     Message = message;
     Level = level;
 }

 public static void Output(string Message, ErrorLevel Level)
 {
     if (Level >= ErrorLevel.Error)
         ErrorStream.WriteLine("{0}: {1}", Level.ToString(), Message);
     else
         Console.WriteLine("{0}: {1}", Level.ToString(), Message);
 }

        public void Log(object message, ErrorLevel level, SocketKey key = null)
        {
            lock (_logLock)
            {
                entries.Add(new LogEntry()
                {
                    timestamp = DateTime.Now,
                    level = level,
                    key = key,
                    message = MsgFmt(message)
                });
            }

            switch (level)
            {
                case ErrorLevel.Info:
                    Debug.Log(KeyFmt(key) + message);
                    break;
                case ErrorLevel.Warning:
                    Debug.LogWarning(KeyFmt(key) + message);
                    break;
                case ErrorLevel.Error:
                    Debug.LogError(KeyFmt(key) + message);
                    break;
            }
        }

 public static void Error(this IEventRegistry registry, IEventSource source, int errorClass, int errorCode, ErrorLevel level, string message, string stackTrace, string errorSource)
 {
     var errorEvent = new ErrorEvent(source, errorClass, errorCode, message);
     errorEvent.ErrorLevel(level);
     errorEvent.StackTrace(stackTrace);
     errorEvent.ErrorSource(errorSource);
     registry.RegisterEvent(errorEvent);
 }

        public static void Log(string message, ErrorLevel x, params string[] args)
        {
            string msg = Build (string.Format (message, args), x);
            Console.WriteLine (msg);

            if (autoFlush)
                Flush ();
        }

 public CompilerException(string fileName, int lineNumber, ErrorLevel level, int errorCode, string message)
 {
     _fileName = fileName;
     _lineNumber = lineNumber;
     _level = level;
     _errorCode = errorCode;
     _message = message;
 }

        public Error(IErrorSource source, string message, ErrorLevel errorLevel)
        {
            if (source == null) throw new ArgumentNullException(nameof(source));

            _source = source;
            _message = message;
            _errorLevel = errorLevel;
        }

 // This is the only thing that needs to be overriden
 public virtual bool Message(MessageSource source, ErrorLevel level, IToken tok, string msg) {
   bool discard = (ErrorsOnly && level != ErrorLevel.Error) || // Discard non-errors if ErrorsOnly is set
                  (tok is TokenWrapper && !(tok is NestedToken) && !(tok is RefinementToken)); // Discard wrapped tokens, except for nested and refinement
   if (!discard) {
     AllMessages[level].Add(new ErrorMessage { token = tok, message = msg });
   }
   return !discard;
 }

 public static void LogException(object ex, ErrorLevel level)
 {
     var e = ex as Exception;
     if (e != null)
     {
         Log(String.Format("{0} - {1}\r\n{2}", level, e.Message, e.StackTrace));
     }
 }

 /// <summary>
 /// Adds an error message to the Error List.
 /// </summary>
 /// <param name="_level">Error level.</param>
 /// <param name="_errorCode">Error code.</param>
 /// <param name="_errorText">Error message text.</param>
 /// <param name="_lineNum">The source code line that raises the error message.</param>
 public static void Add(ErrorLevel _level, string _errorCode, string _errorText, int _lineNum)
 {
     OutputErrorMessage.Instance.Code = _errorCode;
     OutputErrorMessage.Instance.Level = _level;
     OutputErrorMessage.Instance.LineNum = _lineNum;
     OutputErrorMessage.Instance.Text = _errorText;
     Api.SendMessage(Session.CurrentSession.MDIParent.Handle.ToInt32(),
         Convert.ToInt32(MessageHelper.Messages.AddErrorMessage), 0, 0);
 }

        public ErrorEvent(Exception error, int errorCode, ErrorLevel level)
        {
            if (error == null)
                throw new ArgumentNullException("error");

            Error = error;
            ErrorCode = errorCode;
            Level = level;
        }

  		public CompilerError ()
    		{
			ErrorLevel = ErrorLevel.None;
			ErrorMessage = String.Empty;
			SourceFile = String.Empty;
			ErrorNumber = 0;
			SourceColumn = 0;
			SourceLine = 0;
    		}