Write() private method

private Write ( TextWriter output ) : void
output System.IO.TextWriter
return void
Beispiel #1
0
        private static void TryMinifyNumberWithUnit(NumberWithUnitValue value, ReadOnlyDictionary<Unit, decimal> possibleConversions, ref NumberWithUnitValue smallest)
        {
            if (!possibleConversions.ContainsKey(value.Unit)) return;

            var min = MinifyNumberValue(value);

            var ret = new NumberWithUnitValue(min.Value, value.Unit);
            string retStr;
            using (var buffer = new StringWriter())
            {
                ret.Write(buffer);
                retStr = buffer.ToString();
            }

            var inBasic = min.Value * possibleConversions[value.Unit];

            foreach (var unit in possibleConversions.Keys)
            {
                var conversion = possibleConversions[unit];

                var maxPrecision = inBasic / conversion;

                // 5 decimal points seems like an acceptable level of precision; webkit seems to agree
                var inUnit = decimal.Round(maxPrecision, 5);

                var asNum = new NumberValue(inUnit);
                var minified = MinifyNumberValue(asNum);

                var newMin = new NumberWithUnitValue(minified.Value, unit);
                string newMinStr;

                using (var buffer = new StringWriter())
                {
                    newMin.Write(buffer);
                    newMinStr = buffer.ToString();
                }

                if (newMinStr.Length < retStr.Length)
                {
                    ret = newMin;
                    retStr = newMinStr;
                }
            }

            smallest = ret;
        }
Beispiel #2
0
        private static NumberWithUnitValue MinifyNumberWithUnit(NumberWithUnitValue value)
        {
            var min = MinifyNumberValue(value);

            var ret = new NumberWithUnitValue(min.Value, value.Unit);
            string retStr;
            using (var buffer = new StringWriter())
            {
                ret.Write(buffer);
                retStr = buffer.ToString();
            }

            if (Value.ConvertableSizeUnits.ContainsKey(value.Unit))
            {
                var inMM = min.Value * Value.ConvertableSizeUnits[value.Unit];

                foreach (var unit in Value.ConvertableSizeUnits.Keys)
                {
                    var inUnit = inMM / Value.ConvertableSizeUnits[unit];

                    var newMin = new NumberWithUnitValue(MinifyNumberValue(new NumberValue(inUnit)).Value, unit);
                    string newMinStr;

                    using (var buffer = new StringWriter())
                    {
                        newMin.Write(buffer);
                        newMinStr = buffer.ToString();
                    }

                    if (newMinStr.Length < retStr.Length)
                    {
                        ret = newMin;
                        retStr = newMinStr;
                    }
                }
            }

            if (Value.ConvertableTimeUnits.ContainsKey(value.Unit))
            {
                var inS = min.Value * Value.ConvertableTimeUnits[value.Unit];

                foreach (var unit in Value.ConvertableTimeUnits.Keys)
                {
                    var inUnit = inS / Value.ConvertableTimeUnits[unit];
                    var newMin = new NumberWithUnitValue(MinifyNumberValue(new NumberValue(inUnit)).Value, unit);
                    string newMinStr;

                    using (var buffer = new StringWriter())
                    {
                        newMin.Write(buffer);
                        newMinStr = buffer.ToString();
                    }

                    if (newMinStr.Length < retStr.Length)
                    {
                        ret = newMin;
                        retStr = newMinStr;
                    }
                }
            }

            if (Value.ConvertableResolutionUnits.ContainsKey(value.Unit))
            {
                var inDpcm = min.Value * Value.ConvertableResolutionUnits[value.Unit];

                foreach (var unit in Value.ConvertableResolutionUnits.Keys)
                {
                    var inUnit = inDpcm / Value.ConvertableResolutionUnits[unit];
                    var newMin = new NumberWithUnitValue(MinifyNumberValue(new NumberValue(inUnit)).Value, unit);
                    string newMinStr;

                    using (var buffer = new StringWriter())
                    {
                        newMin.Write(buffer);
                        newMinStr = buffer.ToString();
                    }

                    if (newMinStr.Length < retStr.Length)
                    {
                        ret = newMin;
                        retStr = newMinStr;
                    }
                }
            }

            return ret;
        }