BitRate.g.cs

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by \generate-code.bat.
//
//     Changes to this file will be lost when the code is regenerated.
//     The build server regenerates the code before each build and a pre-build
//     step will regenerate the code on each local build.
//
//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
//
//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
//
// </auto-generated>
//------------------------------------------------------------------------------

// Licensed under MIT No Attribution, see LICENSE file at the root.
// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.

using System;
using System.Globalization;
using System.Linq;
using JetBrains.Annotations;
using UnitsNet.Units;
using UnitsNet.InternalHelpers;

// ReSharper disable once CheckNamespace

namespace UnitsNet
{
    /// <summary>
    ///     In telecommunications and computing, bit rate is the number of bits that are conveyed or processed per unit of time.
    /// </summary>
    /// <remarks>
    ///     https://en.wikipedia.org/wiki/Bit_rate
    /// </remarks>
    // Windows Runtime Component has constraints on public types: https://msdn.microsoft.com/en-us/library/br230301.aspx#Declaring types in Windows Runtime Components
    // Public structures can't have any members other than public fields, and those fields must be value types or strings.
    // Public classes must be sealed (NotInheritable in Visual Basic). If your programming model requires polymorphism, you can create a public interface and implement that interface on the classes that must be polymorphic.
    public sealed partial class BitRate : IQuantity
    {
        /// <summary>
        ///     The numeric value this quantity was constructed with.
        /// </summary>
        private readonly decimal _value;

        /// <summary>
        ///     The unit this quantity was constructed with.
        /// </summary>
        private readonly BitRateUnit? _unit;

        static BitRate()
        {
            BaseDimensions = new BaseDimensions(0, 0, -1, 0, 0, 0, 0, 1);
            Info = new QuantityInfo(QuantityType.BitRate, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
        }

        /// <summary>
        ///     Creates the quantity with a value of 0 in the base unit BitPerSecond.
        /// </summary>
        /// <remarks>
        ///     Windows Runtime Component requires a default constructor.
        /// </remarks>
        public BitRate()
        {
            _value = 0;
            _unit = BaseUnit;
        }

        /// <summary>
        ///     Creates the quantity with the given numeric value and unit.
        /// </summary>
        /// <param name="value">The numeric value to construct this quantity with.</param>
        /// <param name="unit">The unit representation to construct this quantity with.</param>
        /// <remarks>Value parameter cannot be named 'value' due to constraint when targeting Windows Runtime Component.</remarks>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        private BitRate(decimal value, BitRateUnit unit)
        {
            if(unit == BitRateUnit.Undefined)
              throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));

            _value = value;
            _unit = unit;
        }

        #region Static Properties

        /// <summary>
        ///     Information about the quantity type, such as unit values and names.
        /// </summary>
        internal static QuantityInfo Info { get; }

        /// <summary>
        ///     The <see cref="BaseDimensions" /> of this quantity.
        /// </summary>
        public static BaseDimensions BaseDimensions { get; }

        /// <summary>
        ///     The base unit of BitRate, which is BitPerSecond. All conversions go via this value.
        /// </summary>
        public static BitRateUnit BaseUnit { get; } = BitRateUnit.BitPerSecond;

        /// <summary>
        /// Represents the largest possible value of BitRate
        /// </summary>
        public static BitRate MaxValue { get; } = new BitRate(decimal.MaxValue, BaseUnit);

        /// <summary>
        /// Represents the smallest possible value of BitRate
        /// </summary>
        public static BitRate MinValue { get; } = new BitRate(decimal.MinValue, BaseUnit);

        /// <summary>
        ///     The <see cref="QuantityType" /> of this quantity.
        /// </summary>
        public static QuantityType QuantityType { get; } = QuantityType.BitRate;

        /// <summary>
        ///     All units of measurement for the BitRate quantity.
        /// </summary>
        public static BitRateUnit[] Units { get; } = Enum.GetValues(typeof(BitRateUnit)).Cast<BitRateUnit>().Except(new BitRateUnit[]{ BitRateUnit.Undefined }).ToArray();

        /// <summary>
        ///     Gets an instance of this quantity with a value of 0 in the base unit BitPerSecond.
        /// </summary>
        public static BitRate Zero { get; } = new BitRate(0, BaseUnit);

        #endregion

        #region Properties

        /// <summary>
        ///     The numeric value this quantity was constructed with.
        /// </summary>
        public double Value => Convert.ToDouble(_value);

        /// <inheritdoc cref="IQuantity.Unit"/>
        object IQuantity.Unit => Unit;

        /// <summary>
        ///     The unit this quantity was constructed with -or- <see cref="BaseUnit" /> if default ctor was used.
        /// </summary>
        public BitRateUnit Unit => _unit.GetValueOrDefault(BaseUnit);

        internal QuantityInfo QuantityInfo => Info;

        /// <summary>
        ///     The <see cref="QuantityType" /> of this quantity.
        /// </summary>
        public QuantityType Type => BitRate.QuantityType;

        /// <summary>
        ///     The <see cref="BaseDimensions" /> of this quantity.
        /// </summary>
        public BaseDimensions Dimensions => BitRate.BaseDimensions;

        #endregion

        #region Conversion Properties

        /// <summary>
        ///     Get BitRate in BitsPerSecond.
        /// </summary>
        public double BitsPerSecond => As(BitRateUnit.BitPerSecond);

        /// <summary>
        ///     Get BitRate in BytesPerSecond.
        /// </summary>
        public double BytesPerSecond => As(BitRateUnit.BytePerSecond);

        /// <summary>
        ///     Get BitRate in ExabitsPerSecond.
        /// </summary>
        public double ExabitsPerSecond => As(BitRateUnit.ExabitPerSecond);

        /// <summary>
        ///     Get BitRate in ExabytesPerSecond.
        /// </summary>
        public double ExabytesPerSecond => As(BitRateUnit.ExabytePerSecond);

        /// <summary>
        ///     Get BitRate in ExbibitsPerSecond.
        /// </summary>
        public double ExbibitsPerSecond => As(BitRateUnit.ExbibitPerSecond);

        /// <summary>
        ///     Get BitRate in ExbibytesPerSecond.
        /// </summary>
        public double ExbibytesPerSecond => As(BitRateUnit.ExbibytePerSecond);

        /// <summary>
        ///     Get BitRate in GibibitsPerSecond.
        /// </summary>
        public double GibibitsPerSecond => As(BitRateUnit.GibibitPerSecond);

        /// <summary>
        ///     Get BitRate in GibibytesPerSecond.
        /// </summary>
        public double GibibytesPerSecond => As(BitRateUnit.GibibytePerSecond);

        /// <summary>
        ///     Get BitRate in GigabitsPerSecond.
        /// </summary>
        public double GigabitsPerSecond => As(BitRateUnit.GigabitPerSecond);

        /// <summary>
        ///     Get BitRate in GigabytesPerSecond.
        /// </summary>
        public double GigabytesPerSecond => As(BitRateUnit.GigabytePerSecond);

        /// <summary>
        ///     Get BitRate in KibibitsPerSecond.
        /// </summary>
        public double KibibitsPerSecond => As(BitRateUnit.KibibitPerSecond);

        /// <summary>
        ///     Get BitRate in KibibytesPerSecond.
        /// </summary>
        public double KibibytesPerSecond => As(BitRateUnit.KibibytePerSecond);

        /// <summary>
        ///     Get BitRate in KilobitsPerSecond.
        /// </summary>
        public double KilobitsPerSecond => As(BitRateUnit.KilobitPerSecond);

        /// <summary>
        ///     Get BitRate in KilobytesPerSecond.
        /// </summary>
        public double KilobytesPerSecond => As(BitRateUnit.KilobytePerSecond);

        /// <summary>
        ///     Get BitRate in MebibitsPerSecond.
        /// </summary>
        public double MebibitsPerSecond => As(BitRateUnit.MebibitPerSecond);

        /// <summary>
        ///     Get BitRate in MebibytesPerSecond.
        /// </summary>
        public double MebibytesPerSecond => As(BitRateUnit.MebibytePerSecond);

        /// <summary>
        ///     Get BitRate in MegabitsPerSecond.
        /// </summary>
        public double MegabitsPerSecond => As(BitRateUnit.MegabitPerSecond);

        /// <summary>
        ///     Get BitRate in MegabytesPerSecond.
        /// </summary>
        public double MegabytesPerSecond => As(BitRateUnit.MegabytePerSecond);

        /// <summary>
        ///     Get BitRate in PebibitsPerSecond.
        /// </summary>
        public double PebibitsPerSecond => As(BitRateUnit.PebibitPerSecond);

        /// <summary>
        ///     Get BitRate in PebibytesPerSecond.
        /// </summary>
        public double PebibytesPerSecond => As(BitRateUnit.PebibytePerSecond);

        /// <summary>
        ///     Get BitRate in PetabitsPerSecond.
        /// </summary>
        public double PetabitsPerSecond => As(BitRateUnit.PetabitPerSecond);

        /// <summary>
        ///     Get BitRate in PetabytesPerSecond.
        /// </summary>
        public double PetabytesPerSecond => As(BitRateUnit.PetabytePerSecond);

        /// <summary>
        ///     Get BitRate in TebibitsPerSecond.
        /// </summary>
        public double TebibitsPerSecond => As(BitRateUnit.TebibitPerSecond);

        /// <summary>
        ///     Get BitRate in TebibytesPerSecond.
        /// </summary>
        public double TebibytesPerSecond => As(BitRateUnit.TebibytePerSecond);

        /// <summary>
        ///     Get BitRate in TerabitsPerSecond.
        /// </summary>
        public double TerabitsPerSecond => As(BitRateUnit.TerabitPerSecond);

        /// <summary>
        ///     Get BitRate in TerabytesPerSecond.
        /// </summary>
        public double TerabytesPerSecond => As(BitRateUnit.TerabytePerSecond);

        #endregion

        #region Static Methods

        /// <summary>
        ///     Get unit abbreviation string.
        /// </summary>
        /// <param name="unit">Unit to get abbreviation for.</param>
        /// <returns>Unit abbreviation string.</returns>
        public static string GetAbbreviation(BitRateUnit unit)
        {
            return GetAbbreviation(unit, null);
        }

        /// <summary>
        ///     Get unit abbreviation string.
        /// </summary>
        /// <param name="unit">Unit to get abbreviation for.</param>
        /// <returns>Unit abbreviation string.</returns>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public static string GetAbbreviation(BitRateUnit unit, [CanBeNull] string cultureName)
        {
            IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
            return UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider);
        }

        #endregion

        #region Static Factory Methods

        /// <summary>
        ///     Get BitRate from BitsPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromBitsPerSecond(double bitspersecond)
        {
            decimal value = (decimal) bitspersecond;
            return new BitRate(value, BitRateUnit.BitPerSecond);
        }
        /// <summary>
        ///     Get BitRate from BytesPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromBytesPerSecond(double bytespersecond)
        {
            decimal value = (decimal) bytespersecond;
            return new BitRate(value, BitRateUnit.BytePerSecond);
        }
        /// <summary>
        ///     Get BitRate from ExabitsPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromExabitsPerSecond(double exabitspersecond)
        {
            decimal value = (decimal) exabitspersecond;
            return new BitRate(value, BitRateUnit.ExabitPerSecond);
        }
        /// <summary>
        ///     Get BitRate from ExabytesPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromExabytesPerSecond(double exabytespersecond)
        {
            decimal value = (decimal) exabytespersecond;
            return new BitRate(value, BitRateUnit.ExabytePerSecond);
        }
        /// <summary>
        ///     Get BitRate from ExbibitsPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromExbibitsPerSecond(double exbibitspersecond)
        {
            decimal value = (decimal) exbibitspersecond;
            return new BitRate(value, BitRateUnit.ExbibitPerSecond);
        }
        /// <summary>
        ///     Get BitRate from ExbibytesPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromExbibytesPerSecond(double exbibytespersecond)
        {
            decimal value = (decimal) exbibytespersecond;
            return new BitRate(value, BitRateUnit.ExbibytePerSecond);
        }
        /// <summary>
        ///     Get BitRate from GibibitsPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromGibibitsPerSecond(double gibibitspersecond)
        {
            decimal value = (decimal) gibibitspersecond;
            return new BitRate(value, BitRateUnit.GibibitPerSecond);
        }
        /// <summary>
        ///     Get BitRate from GibibytesPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromGibibytesPerSecond(double gibibytespersecond)
        {
            decimal value = (decimal) gibibytespersecond;
            return new BitRate(value, BitRateUnit.GibibytePerSecond);
        }
        /// <summary>
        ///     Get BitRate from GigabitsPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromGigabitsPerSecond(double gigabitspersecond)
        {
            decimal value = (decimal) gigabitspersecond;
            return new BitRate(value, BitRateUnit.GigabitPerSecond);
        }
        /// <summary>
        ///     Get BitRate from GigabytesPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromGigabytesPerSecond(double gigabytespersecond)
        {
            decimal value = (decimal) gigabytespersecond;
            return new BitRate(value, BitRateUnit.GigabytePerSecond);
        }
        /// <summary>
        ///     Get BitRate from KibibitsPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromKibibitsPerSecond(double kibibitspersecond)
        {
            decimal value = (decimal) kibibitspersecond;
            return new BitRate(value, BitRateUnit.KibibitPerSecond);
        }
        /// <summary>
        ///     Get BitRate from KibibytesPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromKibibytesPerSecond(double kibibytespersecond)
        {
            decimal value = (decimal) kibibytespersecond;
            return new BitRate(value, BitRateUnit.KibibytePerSecond);
        }
        /// <summary>
        ///     Get BitRate from KilobitsPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromKilobitsPerSecond(double kilobitspersecond)
        {
            decimal value = (decimal) kilobitspersecond;
            return new BitRate(value, BitRateUnit.KilobitPerSecond);
        }
        /// <summary>
        ///     Get BitRate from KilobytesPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromKilobytesPerSecond(double kilobytespersecond)
        {
            decimal value = (decimal) kilobytespersecond;
            return new BitRate(value, BitRateUnit.KilobytePerSecond);
        }
        /// <summary>
        ///     Get BitRate from MebibitsPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromMebibitsPerSecond(double mebibitspersecond)
        {
            decimal value = (decimal) mebibitspersecond;
            return new BitRate(value, BitRateUnit.MebibitPerSecond);
        }
        /// <summary>
        ///     Get BitRate from MebibytesPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromMebibytesPerSecond(double mebibytespersecond)
        {
            decimal value = (decimal) mebibytespersecond;
            return new BitRate(value, BitRateUnit.MebibytePerSecond);
        }
        /// <summary>
        ///     Get BitRate from MegabitsPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromMegabitsPerSecond(double megabitspersecond)
        {
            decimal value = (decimal) megabitspersecond;
            return new BitRate(value, BitRateUnit.MegabitPerSecond);
        }
        /// <summary>
        ///     Get BitRate from MegabytesPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromMegabytesPerSecond(double megabytespersecond)
        {
            decimal value = (decimal) megabytespersecond;
            return new BitRate(value, BitRateUnit.MegabytePerSecond);
        }
        /// <summary>
        ///     Get BitRate from PebibitsPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromPebibitsPerSecond(double pebibitspersecond)
        {
            decimal value = (decimal) pebibitspersecond;
            return new BitRate(value, BitRateUnit.PebibitPerSecond);
        }
        /// <summary>
        ///     Get BitRate from PebibytesPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromPebibytesPerSecond(double pebibytespersecond)
        {
            decimal value = (decimal) pebibytespersecond;
            return new BitRate(value, BitRateUnit.PebibytePerSecond);
        }
        /// <summary>
        ///     Get BitRate from PetabitsPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromPetabitsPerSecond(double petabitspersecond)
        {
            decimal value = (decimal) petabitspersecond;
            return new BitRate(value, BitRateUnit.PetabitPerSecond);
        }
        /// <summary>
        ///     Get BitRate from PetabytesPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromPetabytesPerSecond(double petabytespersecond)
        {
            decimal value = (decimal) petabytespersecond;
            return new BitRate(value, BitRateUnit.PetabytePerSecond);
        }
        /// <summary>
        ///     Get BitRate from TebibitsPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromTebibitsPerSecond(double tebibitspersecond)
        {
            decimal value = (decimal) tebibitspersecond;
            return new BitRate(value, BitRateUnit.TebibitPerSecond);
        }
        /// <summary>
        ///     Get BitRate from TebibytesPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromTebibytesPerSecond(double tebibytespersecond)
        {
            decimal value = (decimal) tebibytespersecond;
            return new BitRate(value, BitRateUnit.TebibytePerSecond);
        }
        /// <summary>
        ///     Get BitRate from TerabitsPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromTerabitsPerSecond(double terabitspersecond)
        {
            decimal value = (decimal) terabitspersecond;
            return new BitRate(value, BitRateUnit.TerabitPerSecond);
        }
        /// <summary>
        ///     Get BitRate from TerabytesPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static BitRate FromTerabytesPerSecond(double terabytespersecond)
        {
            decimal value = (decimal) terabytespersecond;
            return new BitRate(value, BitRateUnit.TerabytePerSecond);
        }

        /// <summary>
        ///     Dynamically convert from value and unit enum <see cref="BitRateUnit" /> to <see cref="BitRate" />.
        /// </summary>
        /// <param name="value">Value to convert from.</param>
        /// <param name="fromUnit">Unit to convert from.</param>
        /// <returns>BitRate unit value.</returns>
        // Fix name conflict with parameter "value"
        [return: System.Runtime.InteropServices.WindowsRuntime.ReturnValueName("returnValue")]
        public static BitRate From(double value, BitRateUnit fromUnit)
        {
            return new BitRate((decimal)value, fromUnit);
        }

        #endregion

        #region Static Parse Methods

        /// <summary>
        ///     Parse a string with one or two quantities of the format "&lt;quantity&gt; &lt;unit&gt;".
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <example>
        ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
        /// </example>
        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
        /// <exception cref="ArgumentException">
        ///     Expected string to have one or two pairs of quantity and unit in the format
        ///     "&lt;quantity&gt; &lt;unit&gt;". Eg. "5.5 m" or "1ft 2in"
        /// </exception>
        /// <exception cref="AmbiguousUnitParseException">
        ///     More than one unit is represented by the specified unit abbreviation.
        ///     Example: Volume.Parse("1 cup") will throw, because it can refer to any of
        ///     <see cref="VolumeUnit.MetricCup" />, <see cref="VolumeUnit.UsLegalCup" /> and <see cref="VolumeUnit.UsCustomaryCup" />.
        /// </exception>
        /// <exception cref="UnitsNetException">
        ///     If anything else goes wrong, typically due to a bug or unhandled case.
        ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
        ///     Units.NET exceptions from other exceptions.
        /// </exception>
        public static BitRate Parse(string str)
        {
            return Parse(str, null);
        }

        /// <summary>
        ///     Parse a string with one or two quantities of the format "&lt;quantity&gt; &lt;unit&gt;".
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <example>
        ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
        /// </example>
        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
        /// <exception cref="ArgumentException">
        ///     Expected string to have one or two pairs of quantity and unit in the format
        ///     "&lt;quantity&gt; &lt;unit&gt;". Eg. "5.5 m" or "1ft 2in"
        /// </exception>
        /// <exception cref="AmbiguousUnitParseException">
        ///     More than one unit is represented by the specified unit abbreviation.
        ///     Example: Volume.Parse("1 cup") will throw, because it can refer to any of
        ///     <see cref="VolumeUnit.MetricCup" />, <see cref="VolumeUnit.UsLegalCup" /> and <see cref="VolumeUnit.UsCustomaryCup" />.
        /// </exception>
        /// <exception cref="UnitsNetException">
        ///     If anything else goes wrong, typically due to a bug or unhandled case.
        ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
        ///     Units.NET exceptions from other exceptions.
        /// </exception>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public static BitRate Parse(string str, [CanBeNull] string cultureName)
        {
            IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
            return QuantityParser.Default.Parse<BitRate, BitRateUnit>(
                str,
                provider,
                From);
        }

        /// <summary>
        ///     Try to parse a string with one or two quantities of the format "&lt;quantity&gt; &lt;unit&gt;".
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <param name="result">Resulting unit quantity if successful.</param>
        /// <example>
        ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
        /// </example>
        public static bool TryParse([CanBeNull] string str, out BitRate result)
        {
            return TryParse(str, null, out result);
        }

        /// <summary>
        ///     Try to parse a string with one or two quantities of the format "&lt;quantity&gt; &lt;unit&gt;".
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <param name="result">Resulting unit quantity if successful.</param>
        /// <returns>True if successful, otherwise false.</returns>
        /// <example>
        ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
        /// </example>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public static bool TryParse([CanBeNull] string str, [CanBeNull] string cultureName, out BitRate result)
        {
            IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
            return QuantityParser.Default.TryParse<BitRate, BitRateUnit>(
                str,
                provider,
                From,
                out result);
        }

        /// <summary>
        ///     Parse a unit string.
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <example>
        ///     Length.ParseUnit("m", new CultureInfo("en-US"));
        /// </example>
        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
        /// <exception cref="UnitsNetException">Error parsing string.</exception>
        public static BitRateUnit ParseUnit(string str)
        {
            return ParseUnit(str, null);
        }

        /// <summary>
        ///     Parse a unit string.
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <example>
        ///     Length.ParseUnit("m", new CultureInfo("en-US"));
        /// </example>
        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
        /// <exception cref="UnitsNetException">Error parsing string.</exception>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public static BitRateUnit ParseUnit(string str, [CanBeNull] string cultureName)
        {
            IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
            return UnitParser.Default.Parse<BitRateUnit>(str, provider);
        }

        public static bool TryParseUnit(string str, out BitRateUnit unit)
        {
            return TryParseUnit(str, null, out unit);
        }

        /// <summary>
        ///     Parse a unit string.
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <param name="unit">The parsed unit if successful.</param>
        /// <returns>True if successful, otherwise false.</returns>
        /// <example>
        ///     Length.TryParseUnit("m", new CultureInfo("en-US"));
        /// </example>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public static bool TryParseUnit(string str, [CanBeNull] string cultureName, out BitRateUnit unit)
        {
            IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
            return UnitParser.Default.TryParse<BitRateUnit>(str, provider, out unit);
        }

        #endregion

        #region Equality / IComparable

        public int CompareTo(object obj)
        {
            if(obj is null) throw new ArgumentNullException(nameof(obj));
            if(!(obj is BitRate objBitRate)) throw new ArgumentException("Expected type BitRate.", nameof(obj));

            return CompareTo(objBitRate);
        }

        // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods
        internal int CompareTo(BitRate other)
        {
            return _value.CompareTo(other.AsBaseNumericType(this.Unit));
        }

        [Windows.Foundation.Metadata.DefaultOverload]
        public override bool Equals(object obj)
        {
            if(obj is null || !(obj is BitRate objBitRate))
                return false;

            return Equals(objBitRate);
        }

        public bool Equals(BitRate other)
        {
            return _value.Equals(other.AsBaseNumericType(this.Unit));
        }

        /// <summary>
        ///     <para>
        ///     Compare equality to another BitRate within the given absolute or relative tolerance.
        ///     </para>
        ///     <para>
        ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
        ///     <paramref name="other"/> as a percentage of this quantity's value. <paramref name="other"/> will be converted into
        ///     this quantity's unit for comparison. A relative tolerance of 0.01 means the absolute difference must be within +/- 1% of
        ///     this quantity's value to be considered equal.
        ///     <example>
        ///     In this example, the two quantities will be equal if the value of b is within +/- 1% of a (0.02m or 2cm).
        ///     <code>
        ///     var a = Length.FromMeters(2.0);
        ///     var b = Length.FromInches(50.0);
        ///     a.Equals(b, 0.01, ComparisonType.Relative);
        ///     </code>
        ///     </example>
        ///     </para>
        ///     <para>
        ///     Absolute tolerance is defined as the maximum allowable absolute difference between this quantity's value and
        ///     <paramref name="other"/> as a fixed number in this quantity's unit. <paramref name="other"/> will be converted into
        ///     this quantity's unit for comparison.
        ///     <example>
        ///     In this example, the two quantities will be equal if the value of b is within 0.01 of a (0.01m or 1cm).
        ///     <code>
        ///     var a = Length.FromMeters(2.0);
        ///     var b = Length.FromInches(50.0);
        ///     a.Equals(b, 0.01, ComparisonType.Absolute);
        ///     </code>
        ///     </example>
        ///     </para>
        ///     <para>
        ///     Note that it is advised against specifying zero difference, due to the nature
        ///     of floating point operations and using System.Double internally.
        ///     </para>
        /// </summary>
        /// <param name="other">The other quantity to compare to.</param>
        /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
        /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
        /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
        public bool Equals(BitRate other, double tolerance, ComparisonType comparisonType)
        {
            if(tolerance < 0)
                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");

            double thisValue = (double)this.Value;
            double otherValueInThisUnits = other.As(this.Unit);

            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
        }

        /// <summary>
        ///     Returns the hash code for this instance.
        /// </summary>
        /// <returns>A hash code for the current BitRate.</returns>
        public override int GetHashCode()
        {
            return new { QuantityType, Value, Unit }.GetHashCode();
        }

        #endregion

        #region Conversion Methods

        double IQuantity.As(object unit) => As((BitRateUnit)unit);

        /// <summary>
        ///     Convert to the unit representation <paramref name="unit" />.
        /// </summary>
        /// <returns>Value converted to the specified unit.</returns>
        public double As(BitRateUnit unit)
        {
            if(Unit == unit)
                return Convert.ToDouble(Value);

            var converted = AsBaseNumericType(unit);
            return Convert.ToDouble(converted);
        }

        /// <summary>
        ///     Converts this BitRate to another BitRate with the unit representation <paramref name="unit" />.
        /// </summary>
        /// <returns>A BitRate with the specified unit.</returns>
        public BitRate ToUnit(BitRateUnit unit)
        {
            var convertedValue = AsBaseNumericType(unit);
            return new BitRate(convertedValue, unit);
        }

        /// <summary>
        ///     Converts the current value + unit to the base unit.
        ///     This is typically the first step in converting from one unit to another.
        /// </summary>
        /// <returns>The value in the base unit representation.</returns>
        private decimal AsBaseUnit()
        {
            switch(Unit)
            {
                case BitRateUnit.BitPerSecond: return _value;
                case BitRateUnit.BytePerSecond: return _value*8m;
                case BitRateUnit.ExabitPerSecond: return (_value) * 1e18m;
                case BitRateUnit.ExabytePerSecond: return (_value*8m) * 1e18m;
                case BitRateUnit.ExbibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024);
                case BitRateUnit.ExbibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024 * 1024);
                case BitRateUnit.GibibitPerSecond: return (_value) * (1024m * 1024 * 1024);
                case BitRateUnit.GibibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024);
                case BitRateUnit.GigabitPerSecond: return (_value) * 1e9m;
                case BitRateUnit.GigabytePerSecond: return (_value*8m) * 1e9m;
                case BitRateUnit.KibibitPerSecond: return (_value) * 1024m;
                case BitRateUnit.KibibytePerSecond: return (_value*8m) * 1024m;
                case BitRateUnit.KilobitPerSecond: return (_value) * 1e3m;
                case BitRateUnit.KilobytePerSecond: return (_value*8m) * 1e3m;
                case BitRateUnit.MebibitPerSecond: return (_value) * (1024m * 1024);
                case BitRateUnit.MebibytePerSecond: return (_value*8m) * (1024m * 1024);
                case BitRateUnit.MegabitPerSecond: return (_value) * 1e6m;
                case BitRateUnit.MegabytePerSecond: return (_value*8m) * 1e6m;
                case BitRateUnit.PebibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024 * 1024);
                case BitRateUnit.PebibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024 * 1024);
                case BitRateUnit.PetabitPerSecond: return (_value) * 1e15m;
                case BitRateUnit.PetabytePerSecond: return (_value*8m) * 1e15m;
                case BitRateUnit.TebibitPerSecond: return (_value) * (1024m * 1024 * 1024 * 1024);
                case BitRateUnit.TebibytePerSecond: return (_value*8m) * (1024m * 1024 * 1024 * 1024);
                case BitRateUnit.TerabitPerSecond: return (_value) * 1e12m;
                case BitRateUnit.TerabytePerSecond: return (_value*8m) * 1e12m;
                default:
                    throw new NotImplementedException($"Can not convert {Unit} to base units.");
            }
        }

        private decimal AsBaseNumericType(BitRateUnit unit)
        {
            if(Unit == unit)
                return _value;

            var baseUnitValue = AsBaseUnit();

            switch(unit)
            {
                case BitRateUnit.BitPerSecond: return baseUnitValue;
                case BitRateUnit.BytePerSecond: return baseUnitValue/8m;
                case BitRateUnit.ExabitPerSecond: return (baseUnitValue) / 1e18m;
                case BitRateUnit.ExabytePerSecond: return (baseUnitValue/8m) / 1e18m;
                case BitRateUnit.ExbibitPerSecond: return (baseUnitValue) / (1024m * 1024 * 1024 * 1024 * 1024 * 1024);
                case BitRateUnit.ExbibytePerSecond: return (baseUnitValue/8m) / (1024m * 1024 * 1024 * 1024 * 1024 * 1024);
                case BitRateUnit.GibibitPerSecond: return (baseUnitValue) / (1024m * 1024 * 1024);
                case BitRateUnit.GibibytePerSecond: return (baseUnitValue/8m) / (1024m * 1024 * 1024);
                case BitRateUnit.GigabitPerSecond: return (baseUnitValue) / 1e9m;
                case BitRateUnit.GigabytePerSecond: return (baseUnitValue/8m) / 1e9m;
                case BitRateUnit.KibibitPerSecond: return (baseUnitValue) / 1024m;
                case BitRateUnit.KibibytePerSecond: return (baseUnitValue/8m) / 1024m;
                case BitRateUnit.KilobitPerSecond: return (baseUnitValue) / 1e3m;
                case BitRateUnit.KilobytePerSecond: return (baseUnitValue/8m) / 1e3m;
                case BitRateUnit.MebibitPerSecond: return (baseUnitValue) / (1024m * 1024);
                case BitRateUnit.MebibytePerSecond: return (baseUnitValue/8m) / (1024m * 1024);
                case BitRateUnit.MegabitPerSecond: return (baseUnitValue) / 1e6m;
                case BitRateUnit.MegabytePerSecond: return (baseUnitValue/8m) / 1e6m;
                case BitRateUnit.PebibitPerSecond: return (baseUnitValue) / (1024m * 1024 * 1024 * 1024 * 1024);
                case BitRateUnit.PebibytePerSecond: return (baseUnitValue/8m) / (1024m * 1024 * 1024 * 1024 * 1024);
                case BitRateUnit.PetabitPerSecond: return (baseUnitValue) / 1e15m;
                case BitRateUnit.PetabytePerSecond: return (baseUnitValue/8m) / 1e15m;
                case BitRateUnit.TebibitPerSecond: return (baseUnitValue) / (1024m * 1024 * 1024 * 1024);
                case BitRateUnit.TebibytePerSecond: return (baseUnitValue/8m) / (1024m * 1024 * 1024 * 1024);
                case BitRateUnit.TerabitPerSecond: return (baseUnitValue) / 1e12m;
                case BitRateUnit.TerabytePerSecond: return (baseUnitValue/8m) / 1e12m;
                default:
                    throw new NotImplementedException($"Can not convert {Unit} to {unit}.");
            }
        }

        #endregion

        #region ToString Methods

        /// <summary>
        ///     Get default string representation of value and unit.
        /// </summary>
        /// <returns>String representation.</returns>
        public override string ToString()
        {
            return ToString(null);
        }

        /// <summary>
        ///     Get string representation of value and unit. Using two significant digits after radix.
        /// </summary>
        /// <returns>String representation.</returns>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use for localization and number formatting. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public string ToString([CanBeNull] string cultureName)
        {
            var provider = cultureName;
            return ToString(provider, 2);
        }

        /// <summary>
        ///     Get string representation of value and unit.
        /// </summary>
        /// <param name="significantDigitsAfterRadix">The number of significant digits after the radix point.</param>
        /// <returns>String representation.</returns>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use for localization and number formatting. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public string ToString(string cultureName, int significantDigitsAfterRadix)
        {
            var provider = cultureName;
            var value = Convert.ToDouble(Value);
            var format = UnitFormatter.GetFormat(value, significantDigitsAfterRadix);
            return ToString(provider, format);
        }

        /// <summary>
        ///     Get string representation of value and unit.
        /// </summary>
        /// <param name="format">String format to use. Default:  "{0:0.##} {1} for value and unit abbreviation respectively."</param>
        /// <param name="args">Arguments for string format. Value and unit are implicitly included as arguments 0 and 1.</param>
        /// <returns>String representation.</returns>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use for localization and number formatting. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public string ToString([CanBeNull] string cultureName, [NotNull] string format, [NotNull] params object[] args)
        {
            var provider = GetFormatProviderFromCultureName(cultureName);
            if (format == null) throw new ArgumentNullException(nameof(format));
            if (args == null) throw new ArgumentNullException(nameof(args));

            provider = provider ?? GlobalConfiguration.DefaultCulture;

            var value = Convert.ToDouble(Value);
            var formatArgs = UnitFormatter.GetFormatArgs(Unit, value, provider, args);
            return string.Format(provider, format, formatArgs);
        }

        #endregion

        private static IFormatProvider GetFormatProviderFromCultureName([CanBeNull] string cultureName)
        {
            return cultureName != null ? new CultureInfo(cultureName) : (IFormatProvider)null;
        }
    }
}