public override bool TryCompare(IDateTimeDiffTO dateTimeDiffTo, out string result, out string error)
        {
            result = "";
            error  = "";
            var dateTimeParser  = DateTimeConverterFactory.CreateStandardParser();
            var parsedCorreclty = DateTime.TryParseExact(dateTimeDiffTo.Input1, dateTimeDiffTo.InputFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out var parsedDate);

            if (parsedCorreclty)
            {
                _input1         = parsedDate;
                parsedCorreclty = DateTime.TryParseExact(dateTimeDiffTo.Input2, dateTimeDiffTo.InputFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out var parsedDate1);


                if (parsedCorreclty)
                {
                    _input2         = parsedDate1;
                    parsedCorreclty = OutputFormats.TryGetValue(dateTimeDiffTo.OutputType, out Func <DateTime, DateTime, double> returnedFunc);

                    if (returnedFunc != null)
                    {
                        var tmpAmount  = returnedFunc.Invoke(_input1, _input2);
                        var wholeValue = Convert.ToInt64(Math.Floor(tmpAmount));
                        result = wholeValue.ToString(CultureInfo.InvariantCulture);
                    }
                }

                return(parsedCorreclty);
            }
            error = ErrorResource.CannorParseInputDateTimeWithGivenFormat;
            return(parsedCorreclty);
        }
Esempio n. 2
0
        private WmsProvider(Client wmsClient, Func <string, Task <Stream> > getStreamAsync = null)
        {
            InitialiseGetStreamAsyncMethod(getStreamAsync);
            _wmsClient      = wmsClient;
            TimeOut         = 10000;
            ContinueOnError = true;

            if (OutputFormats.Contains("image/png"))
            {
                _mimeType = "image/png";
            }
            else if (OutputFormats.Contains("image/gif"))
            {
                _mimeType = "image/gif";
            }
            else if (OutputFormats.Contains("image/jpeg"))
            {
                _mimeType = "image/jpeg";
            }
            else //None of the default formats supported - Look for the first supported output format
            {
                throw new ArgumentException(
                          "None of the formates provided by the WMS service are supported");
            }
            LayerList  = new Collection <string>();
            StylesList = new Collection <string>();
        }
 public static IOutputDescription CreateOutputDescription(OutputFormats format)
 {
     return new OutputDescription
     {
         Format = format,
     };
 }
Esempio n. 4
0
        static void Main(string[] args)
        {
            try
            {
                String        sourceDirectory = args[0];
                String        destDirectory   = args[1];
                OutputFormats outFormats      = OutputFormats.Uncompressed;
                if (args.Length > 2)
                {
                    Enum.TryParse(args[2], out outFormats);
                }

                int maxSize = int.MaxValue;
                if (args.Length > 3)
                {
                    if (!int.TryParse(args[3], out maxSize))
                    {
                        maxSize = int.MaxValue;
                    }
                }

                Environment.CurrentDirectory = sourceDirectory;

                Logging.Log.Default.addLogListener(new Logging.LogConsoleListener());
                WindowsRuntimePlatformInfo.Initialize();
                PluginManager pluginManager = new PluginManager(new ConfigFile("woot.txt"), new ServiceCollection());
                VirtualFileSystem.Instance.addArchive(destDirectory);

                TextureCompilerInterface.CompileTextures(sourceDirectory, destDirectory, pluginManager, outFormats, maxSize);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
Esempio n. 5
0
        public MainViewModel(IEnumerable <IModelReaderAsync> readers,
                             IEnumerable <IModelWriterAsync> writers)
        {
            if (!readers.Any())
            {
                throw new ArgumentException(nameof(readers));
            }

            if (!writers.Any())
            {
                throw new ArgumentException(nameof(writers));
            }

            _readers = readers;
            _writers = writers;

            OutputFormats        = _writers.Select(w => w.FormatDescription).ToArray();
            SelectedOutputFormat = OutputFormats.First();

            BrowseInputFileCommand  = new BasicCommand(DoBrowseInput);
            BrowseOutputFileCommand = new BasicCommand(DoBrowseOutput);
            ExitCommand             = new BasicCommand(DoExit);
            _convertCommand         = new AsyncCommand(Convert, CanConvert);
            CancelCommand           = new BasicCommand(DoCancel);
        }
 public static IOutputDescription CreateOutputDescription(OutputFormats format)
 {
     return(new OutputDescription
     {
         Format = format,
     });
 }
        private void PopulatePossibleOutputFormats(string inputDocument)
        {
            var outputFormats = new Dictionary <string, List <ListItem> >();

            foreach (var format in DocumentUltimate.DocumentConverter.EnumeratePossibleOutputFormats(inputDocument))
            {
                var formatInfo = DocumentFormatInfo.Get(format);

                List <ListItem> groupData;
                if (!outputFormats.TryGetValue(formatInfo.Group.Description, out groupData))
                {
                    groupData = new List <ListItem>();
                    outputFormats.Add(formatInfo.Group.Description, groupData);
                }
                groupData.Add(new ListItem(formatInfo.Description, formatInfo.Value.ToString()));
            }

            if (outputFormats.Count == 0)
            {
                outputFormats.Add("(not supported)", new List <ListItem>());
            }

            OutputFormats.DataSource = outputFormats;
            OutputFormats.DataBind();
        }
Esempio n. 8
0
 /// <summary>
 /// Sets the image type to use when requesting images from the WMS server
 /// </summary>
 /// <remarks>
 /// <para>See the <see cref="OutputFormats"/> property for a list of available mime types supported by the WMS server</para>
 /// </remarks>
 /// <exception cref="ArgumentException">Throws an exception if either the mime type isn't offered by the WMS
 /// or GDI+ doesn't support this mime type.</exception>
 /// <param name="mimeType">Mime type of image format</param>
 public void SetImageFormat(string mimeType)
 {
     if (!OutputFormats.Contains(mimeType))
     {
         throw new ArgumentException("WMS service doesn't not offer mimetype '" + mimeType + "'");
     }
     _mimeType = mimeType;
 }
Esempio n. 9
0
        /// <summary>
        ///     Return a filename for the current image format (png,jpg etc) with the default file pattern
        ///     that is specified in the configuration
        /// </summary>
        /// <param name="format">A string with the format</param>
        /// <param name="captureDetails"></param>
        /// <returns>The filename which should be used to save the image</returns>
        public static string GetFilename(OutputFormats format, ICaptureDetails captureDetails)
        {
            var pattern = CoreConfig.OutputFileFilenamePattern;

            if (string.IsNullOrEmpty(pattern?.Trim()))
            {
                pattern = "greenshot ${capturetime}";
            }
            return(GetFilenameFromPattern(pattern, format, captureDetails));
        }
Esempio n. 10
0
 /// <summary>
 /// Initializes a new layer, and downloads and parses the service description
 /// </summary>
 /// <param name="layername">Layername</param>
 /// <param name="url">Url of WMS server</param>
 /// <param name="cachetime">Time for caching Service Description (ASP.NET only)</param>
 /// <param name="proxy">Proxy</param>
 /// <param name="credentials"></param>
 public WmsLayer(string layername, string url, TimeSpan cachetime, WebProxy proxy, ICredentials credentials)
 {
     _Proxy           = proxy;
     _TimeOut         = 10000;
     LayerName        = layername;
     _ContinueOnError = true;
     _Credentials     = credentials;
     if (HttpContext.Current != null && HttpContext.Current.Cache["SharpMap_WmsClient_" + url] != null)
     {
         wmsClient = (Client)HttpContext.Current.Cache["SharpMap_WmsClient_" + url];
     }
     else
     {
         wmsClient = new Client(url, _Proxy, _Credentials);
         if (HttpContext.Current != null)
         {
             HttpContext.Current.Cache.Insert("SharpMap_WmsClient_" + url, wmsClient, null,
                                              Cache.NoAbsoluteExpiration, cachetime);
         }
     }
     //Set default mimetype - We prefer compressed formats
     if (OutputFormats.Contains("image/jpeg"))
     {
         _MimeType = "image/jpeg";
     }
     else if (OutputFormats.Contains("image/png"))
     {
         _MimeType = "image/png";
     }
     else if (OutputFormats.Contains("image/gif"))
     {
         _MimeType = "image/gif";
     }
     else //None of the default formats supported - Look for the first supported output format
     {
         bool formatSupported = false;
         foreach (ImageCodecInfo encoder in ImageCodecInfo.GetImageEncoders())
         {
             if (OutputFormats.Contains(encoder.MimeType.ToLower()))
             {
                 formatSupported = true;
                 _MimeType       = encoder.MimeType;
                 break;
             }
         }
         if (!formatSupported)
         {
             throw new ArgumentException(
                       "GDI+ doesn't not support any of the mimetypes supported by this WMS service");
         }
     }
     _LayerList  = new Collection <string>();
     _StylesList = new Collection <string>();
 }
Esempio n. 11
0
 public static object Execute(string strsql, OutputFormats output, object InputObject)
 {
     if (transaction)
     {
         sqls += strsql + "\n";
         return(null);
     }
     else
     {
         return(_execute(strsql, output, InputObject));
     }
 }
Esempio n. 12
0
        private static object _execute(string sql, OutputFormats output, object InputObject)
        {
            check_connection();
            switch (output)
            {
            case OutputFormats.Nothing:
            {
                sqlclient.Execute(sql, null, null);
                return(null);
            }

            case OutputFormats.IEnumerableOfList:
            {
                ArrayList data = new ArrayList();
                sqlclient.Execute(sql, (obj, ColumnNames, RowData) =>
                    {
                        IList _data = obj as IList;
                        _data.Add(RowData);
                        return(0);
                    }, data);

                return(data.Cast <IList>());
            }

            case OutputFormats.DataTable:
                throw new NotImplementedException();

            case OutputFormats.DataGridView:
            {
                sqlclient.Execute(sql, (obj, ColumnNames, RowData) =>
                    {
                        System.Windows.Forms.DataGridView dg = (System.Windows.Forms.DataGridView)obj;

                        if (dg == null)     //make a new one!
                        {
                            dg = new System.Windows.Forms.DataGridView();
                        }
                        if (dg.Columns.Count == 0)     // add columns as necessary
                        {
                            System.Array.ForEach(ColumnNames, (s) => { dg.Columns.Add(s, s); });
                        }

                        dg.Rows.Add(RowData);
                        return(0);
                    }, InputObject);
                return(InputObject);
            }

            default:
                throw new NotImplementedException();
            }
        }
Esempio n. 13
0
        public Synthesizer(Uri endpointUri, OutputFormats outputFormats, AuthClient authorization)
        {
            SynthesizeQueue = new List <SynthesizeTask>();

            EndpointUri = endpointUri;

            DescriptionAttribute[] attributes = (DescriptionAttribute[])outputFormats.GetType().GetField(outputFormats.ToString()).GetCustomAttributes(typeof(DescriptionAttribute), false);
            string description = attributes.Length > 0 ? attributes[0].Description : string.Empty;

            OutputFormat = description;

            AuthorizationClient = authorization;
        }
Esempio n. 14
0
 private void Initialize()
 {
     continueOnError = true;
     if (System.Web.HttpContext.Current != null && System.Web.HttpContext.Current.Cache["SharpMap_WmsClient_" + url] != null)
     {
         wmsClient = (SharpMap.Web.Wms.Client)System.Web.HttpContext.Current.Cache["SharpMap_WmsClient_" + url];
     }
     else
     {
         wmsClient = new SharpMap.Web.Wms.Client(url, proxy);
         if (System.Web.HttpContext.Current != null)
         {
             System.Web.HttpContext.Current.Cache.Insert("SharpMap_WmsClient_" + url, wmsClient, null,
                                                         System.Web.Caching.Cache.NoAbsoluteExpiration, cachetime);
         }
     }
     //Set default mimetype - We prefer compressed formats
     if (OutputFormats.Contains("image/jpeg"))
     {
         mimeType = "image/jpeg";
     }
     else if (OutputFormats.Contains("image/png"))
     {
         mimeType = "image/png";
     }
     else if (OutputFormats.Contains("image/gif"))
     {
         mimeType = "image/gif";
     }
     else //None of the default formats supported - Look for the first supported output format
     {
         bool formatSupported = false;
         foreach (System.Drawing.Imaging.ImageCodecInfo encoder in System.Drawing.Imaging.ImageCodecInfo.GetImageEncoders())
         {
             if (OutputFormats.Contains(encoder.MimeType.ToLower()))
             {
                 formatSupported = true;
                 mimeType        = encoder.MimeType;
                 break;
             }
         }
         if (!formatSupported)
         {
             throw new ArgumentException("GDI+ doesn't not support any of the mimetypes supported by this WMS service");
         }
     }
     layerList  = new Collection <string>();
     stylesList = new Collection <string>();
 }
Esempio n. 15
0
 public void Initialize(string[] args)
 {
     parser.Parse(args);
     if (showUsage)
     {
         throw new OperationCanceledException();
     }
     if (!AssemblyFiles.Any())
     {
         throw new OptionException("No assembly file is specified", null);
     }
     if (!OutputFormats.Any())
     {
         throw new OptionException("No document format is specified", null);
     }
 }
Esempio n. 16
0
        private WmsProvider(Client wmsClient)
        {
            this.wmsClient = wmsClient;
            TimeOut = 10000;
            ContinueOnError = true;

            if (OutputFormats.Contains("image/png")) mimeType = "image/png";
            else if (OutputFormats.Contains("image/gif")) mimeType = "image/gif";
            else if (OutputFormats.Contains("image/jpeg")) mimeType = "image/jpeg";
            else //None of the default formats supported - Look for the first supported output format
            {
                throw new ArgumentException(
                    "None of the formates provided by the WMS service are supported");
            }
            LayerList = new Collection<string>();
            StylesList = new Collection<string>();
        }
Esempio n. 17
0
        protected override bool ValidateValues()
        {
            // If nothing is set, default to ShowNonPortableApis
            if ((RequestFlags & (AnalyzeRequestFlags.ShowBreakingChanges | AnalyzeRequestFlags.ShowNonPortableApis)) == AnalyzeRequestFlags.None)
            {
                RequestFlags |= AnalyzeRequestFlags.ShowNonPortableApis;
            }

            // If no output formats have been supplied, default to Excel
            // TODO: Should probably get this from the service, not hard-coded
            if (!OutputFormats.Any())
            {
                UpdateOutputFormats("Excel");
            }

            return(InputAssemblies.Any());
        }
        private void PopulateOutputFormats()
        {
            var outputFormats = new Dictionary <string, List <ListItem> >();

            foreach (var formatInfo in DocumentFormatInfo.Enumerate(DocumentFormatSupport.Save))
            {
                List <ListItem> groupData;
                if (!outputFormats.TryGetValue(formatInfo.Group.Description, out groupData))
                {
                    groupData = new List <ListItem>();
                    outputFormats.Add(formatInfo.Group.Description, groupData);
                }
                groupData.Add(new ListItem(formatInfo.Description, formatInfo.Value.ToString()));
                OutputFormatCount++;
            }

            OutputFormats.DataSource = outputFormats;
            OutputFormats.DataBind();
        }
Esempio n. 19
0
        public Log(FileInfo fileInfo, PriorityLevels filePriority = PriorityLevels.UltraLow, FileWriteModes writeMode = FileWriteModes.Overwrite, PriorityLevels debugPriority = PriorityLevels.UltraLow, PriorityLevels consolePriority = PriorityLevels.UltraLow, OutputFormats output = OutputFormats.File | OutputFormats.Debugger, bool enable = true)
        {
            FileInfo         = fileInfo;
            FilePriority     = filePriority;
            FileWriteMode    = writeMode;
            DebuggerPriority = debugPriority;
            ConsolePriority  = consolePriority;
            Output           = output;
            IsEnabled        = enable;
            WriteToFileCount = 0;
            Messages         = new ConcurrentBag <LogMessage>();

            _logCount++;

            if (_logCount == 1)
            {
                LogToFileBackgroundTask();
            }
        }
Esempio n. 20
0
        /// <summary>
        /// Creates an instance of this class
        /// </summary>
        /// <param name="layername"></param>
        /// <param name="wmsClient"></param>
        public WmsLayer(string layername, Client wmsClient)
            : base(new Style(), new NullRenderer())
        {
            _wmsClient       = wmsClient;
            _continueOnError = true;

            LayerName = layername;
            //Set default mimetype - We prefer compressed formats
            if (OutputFormats.Contains("image/jpeg"))
            {
                _mimeType = "image/jpeg";
            }
            else if (OutputFormats.Contains("image/png"))
            {
                _mimeType = "image/png";
            }
            else if (OutputFormats.Contains("image/gif"))
            {
                _mimeType = "image/gif";
            }
            else //None of the default formats supported - Look for the first supported output format
            {
                bool formatSupported = false;
                foreach (ImageCodecInfo encoder in ImageCodecInfo.GetImageEncoders())
                {
                    if (OutputFormats.Contains(encoder.MimeType.ToLower()))
                    {
                        formatSupported = true;
                        _mimeType       = encoder.MimeType;
                        break;
                    }
                }
                if (!formatSupported)
                {
                    throw new ArgumentException(
                              "GDI+ doesn't not support any of the mimetypes supported by this WMS service");
                }
            }
            _layerList  = new Collection <string>();
            _stylesList = new Collection <string>();
        }
Esempio n. 21
0
        public async Task <Stream> ParseCsvAsync(string csvUri, OutputFormats ouputFormat)
        {
            try
            {
                if (!Uri.IsWellFormedUriString(csvUri, UriKind.Absolute))
                {
                    Console.WriteLine("The Uri is not Well Formatted");

                    return(null);
                }

                bool isUriCreated = Uri.TryCreate(csvUri, UriKind.Absolute, out Uri uri);

                if (isUriCreated == false || uri == null)
                {
                    Console.WriteLine("Invalid Uri");

                    return(null);
                }


                if (Path.GetExtension(csvUri) != ".csv")
                {
                    Console.WriteLine("Invalid Csv file");

                    return(null);
                }

                return(await CsvParserService.ParseCsvAsync(csvUri, ouputFormat));
            }

            catch (Exception e)
            {
                Logger.LogError($"Error: {e.Message}");

                return(null);
            }
        }
Esempio n. 22
0
        public async Task Run(string ouputFormat)
        {
            Console.WriteLine("Enter The Uri for the Csv File");
            string csvUri = Console.ReadLine();

            Console.WriteLine();

            if (string.IsNullOrEmpty(csvUri))
            {
                Console.WriteLine("No Uri was provided for the Csv file");

                return;
            }

            OutputFormats outputformat = OutputFormats.console;

            if (!string.IsNullOrEmpty(ouputFormat) &&
                Enum.IsDefined(typeof(OutputFormats), ouputFormat.ToLower()))
            {
                outputformat = (OutputFormats)Enum.Parse(typeof(OutputFormats), ouputFormat.ToLower());
            }

            using (Stream stream = await CsvParserLogic.ParseCsvAsync(csvUri, outputformat))
            {
                if (stream != null)
                {
                    StreamReader reader = new StreamReader(stream);

                    Console.BufferHeight = short.MaxValue - 1;

                    Console.WriteLine(await reader.ReadToEndAsync());
                }
                else
                {
                    Console.WriteLine("The Output stream is empty");
                }
            }
        }
Esempio n. 23
0
        /// <summary>
        /// Sets the image type to use when requesting images from the WMS server
        /// </summary>
        /// <remarks>
        /// <para>See the <see cref="OutputFormats"/> property for a list of available mime types supported by the WMS server</para>
        /// </remarks>
        /// <exception cref="ArgumentException">Throws an exception if either the mime type isn't offered by the WMS
        /// or GDI+ doesn't support this mime type.</exception>
        /// <param name="mimeType">Mime type of image format</param>
        public void SetImageFormat(string mimeType)
        {
            if (!OutputFormats.Contains(mimeType))
            {
                throw new ArgumentException("WMS service doesn't not offer mimetype '" + mimeType + "'");
            }
            //Check whether SharpMap supports the specified mimetype
            bool formatSupported = false;

            foreach (ImageCodecInfo encoder in ImageCodecInfo.GetImageEncoders())
            {
                if (encoder.MimeType.ToLower() == mimeType.ToLower())
                {
                    formatSupported = true;
                    break;
                }
            }
            if (!formatSupported)
            {
                throw new ArgumentException("GDI+ doesn't not support mimetype '" + mimeType + "'");
            }
            _MimeType = mimeType;
        }
Esempio n. 24
0
        /// <summary>
        /// Sets the image type to use when requesting images from the WMS server
        /// </summary>
        /// <remarks>
        /// <para>See the <see cref="OutputFormats"/> property for a list of available mime types supported by the WMS server</para>
        /// </remarks>
        /// <exception cref="ArgumentException">Throws an exception if either the mime type isn't offered by the WMS
        /// or GDI+ doesn't support this mime type.</exception>
        /// <param name="mimeType">Mime type of image format</param>
        public void SetImageFormat(string mimeType)
        {
            if (!OutputFormats.Contains(mimeType))
            {
                throw new ArgumentException("WMS service doesn't not offer mimetype '" + mimeType + "'");
            }
            //Check whether SharpMap supports the specified mimetype
            var formatSupported = false;

            foreach (var encoder in ImageCodecInfo.GetImageEncoders())
            {
                if (string.Equals(encoder.MimeType, mimeType, StringComparison.CurrentCultureIgnoreCase))
                {
                    formatSupported = true;
                    break;
                }
            }
            if (!formatSupported)
            {
                throw new ArgumentException("GDI+ doesn't not support mimetype '" + mimeType + "'");
            }
            _mimeType = mimeType;
        }
Esempio n. 25
0
 public SurfaceOutputSettings(OutputFormats format, int quality, bool reduceColors) : this(format, quality)
 {
     ReduceColors = reduceColors;
 }
Esempio n. 26
0
 public SurfaceOutputSettings(OutputFormats format, int quality) : this(format)
 {
     JPGQuality = quality;
 }
Esempio n. 27
0
 public SurfaceOutputSettings(OutputFormats format) : this()
 {
     Format = format;
 }
Esempio n. 28
0
 public IApiDocumentation GetApiEntryPointDescription(OutputFormats format)
 {
     return(GetApiEntryPointDescription(OverrideAcceptedMediaType(format)));
 }
Esempio n. 29
0
        public static void DetectOutputFormat(string str, out OutputFormats outputFormat, out OutputDigitLanguages outputDigitLanguage)
        {
            outputFormat        = OutputFormats.LettersWithSign;
            outputDigitLanguage = OutputDigitLanguages.None;

            int len = str.Length;

            if ((str[0] == '-' || str[0] == '+') && (len > 1 && Char.IsLetter(str[1])))
            {
                outputDigitLanguage = OutputDigitLanguages.None;
                outputFormat        = OutputFormats.LettersWithSign;
                return;
            }

            for (int i = 0; i < len; i++)
            {
                char ch = str[i];
                if (ch == '/')
                {
                    outputFormat = OutputFormats.Fractional;
                    if (outputDigitLanguage != OutputDigitLanguages.None)
                    {
                        break;
                    }
                }
                else if (Char.IsLetter(ch) && ch != 'e' && ch != 'E')
                {
                    outputFormat        = OutputFormats.Letters;
                    outputDigitLanguage = OutputDigitLanguages.None;
                    break;
                }
                //else if(StringUtil.IsDecimalSeparator(ch))
                //{
                //    outputFormat = OutputFormats.FloatingPoint;
                //    if(outputDigitLanguage != OutputDigitLanguages.None)
                //        break;
                //}
                else if (StringUtil.IsThousandSeparator(ch))
                {
                    outputFormat = OutputFormats.FloatingPointWithSep;
                    if (outputDigitLanguage != OutputDigitLanguages.None)
                    {
                        break;
                    }
                }
                else if (Char.IsDigit(ch))
                {
                    if (StringUtil.IsPersianDigit(ch))
                    {
                        outputDigitLanguage = OutputDigitLanguages.Persian;
                        if (outputFormat != OutputFormats.LettersWithSign)
                        {
                            break;
                        }
                    }
                    else
                    {
                        outputDigitLanguage = OutputDigitLanguages.English;
                        if (outputFormat != OutputFormats.LettersWithSign)
                        {
                            break;
                        }
                    }
                }
            }

            if (outputFormat == OutputFormats.LettersWithSign) // i.e., it was not set in the loop above
            {
                outputFormat = OutputFormats.FloatingPoint;
                Debug.Assert(outputDigitLanguage != OutputDigitLanguages.None);
            }
        }
 public static IOutputDescription CreateOutputDescription(OutputFormats format) => new OutputDescription
 {
     Format = format,
 };
Esempio n. 31
0
 public Log(PriorityLevels filePriority = PriorityLevels.UltraLow, FileWriteModes writeMode = FileWriteModes.Overwrite, PriorityLevels debugPriority = PriorityLevels.UltraLow, PriorityLevels consolePriority = PriorityLevels.UltraLow, OutputFormats output = OutputFormats.File | OutputFormats.Debugger, bool enable = true)
     : this(new FileInfo($@"{ AppDomain.CurrentDomain.BaseDirectory }\{ DefaultGlobalLogFilename }"), filePriority, writeMode, debugPriority, consolePriority, output, enable)
 {
 }