示例#1
0
        internal static bool TryRead(string text, out IReadOnlyList <SymbolAndPower> result)
        {
            var pos     = 0;
            var success = TryRead(text, ref pos, out result);

            return(success && WhiteSpaceReader.IsRestWhiteSpace(text, pos));
        }
示例#2
0
        internal static PaddedFormat GetOrCreate(string format)
        {
            if (String.IsNullOrEmpty(format))
            {
                return(PaddedFormat.NullFormat);
            }

            PaddedFormat match;

            if (Cache.TryGet(format, out match))
            {
                return(match);
            }

            int pos          = 0;
            var paddedFormat = GetOrCreate(format, ref pos);

            if (!WhiteSpaceReader.IsRestWhiteSpace(format, pos))
            {
                paddedFormat = paddedFormat.AsUnknownFormat();
            }

            Cache.Add(format, paddedFormat);
            return(paddedFormat);
        }
示例#3
0
            internal Caches()
            {
                var units = GetUnits();

                foreach (var unit in units)
                {
                    this.symbolUnitMap.Add(unit.Symbol, unit);

                    var pos = 0;
                    if (SymbolAndPowerReader.TryRead(unit.Symbol, ref pos, out IReadOnlyList <SymbolAndPower> result))
                    {
                        if (!WhiteSpaceReader.IsRestWhiteSpace(unit.Symbol, pos))
                        {
                            throw new InvalidOperationException($"Failed splitting {((IUnit)unit).Symbol} into {nameof(SymbolAndPower)}");
                        }

                        if (result.Count == 0)
                        {
                            throw new InvalidOperationException($"Did not find any parts in {unit.Symbol}");
                        }

                        this.symbolPartsMap.Add(unit.Symbol, result);
                        var sapSet = new ReadonlySet <SymbolAndPower>(result);
                        this.unitPartsMap.TryAdd(sapSet, unit);
                    }
                }
            }
示例#4
0
        internal static bool TryParse(string text, out TUnit value)
        {
            var pos = 0;

            WhiteSpaceReader.TryRead(text, ref pos);
            return(TryParse(text, ref pos, out value) &&
                   WhiteSpaceReader.IsRestWhiteSpace(text, pos));
        }
示例#5
0
        private static bool IsEndOfSymbol(string text, int pos)
        {
            if (pos == text.Length)
            {
                return(true);
            }

            return(text[pos] == '}' || WhiteSpaceReader.IsRestWhiteSpace(text, pos));
        }
        internal static bool TryRead(string text, [NotNullWhen(true)] out IReadOnlyList <SymbolAndPower>?result)
        {
            var pos     = 0;
            var success = TryRead(text, ref pos, out result);

#pragma warning disable CS8762 // Parameter must have a non-null value when exiting in some condition.
            return(success && WhiteSpaceReader.IsRestWhiteSpace(text, pos));

#pragma warning restore CS8762 // Parameter must have a non-null value when exiting in some condition.
        }
示例#7
0
        internal static PaddedFormat GetOrCreate(string format, ref int pos, out TUnit unit)
        {
            var start = pos;

            WhiteSpaceReader.TryRead(format, ref pos, out string prePadding);
            if (format == null ||
                pos == format.Length)
            {
                pos  = start;
                unit = Unit <TUnit> .Default;
                return(PaddedFormat.CreateUnknown(prePadding, null));
            }

            if (Cache.TryGetUnitForSymbol(format, ref pos, out string symbol, out unit))
            {
                if (WhiteSpaceReader.IsRestWhiteSpace(format, pos))
                {
                    WhiteSpaceReader.TryRead(format, ref pos, out string postPadding);
                    return(new PaddedFormat(prePadding, symbol, postPadding));
                }

                pos -= symbol.Length;
            }

            if (SymbolAndPowerReader.TryRead(format, ref pos, out IReadOnlyList <SymbolAndPower> symbolsAndPowers))
            {
                symbol = format.Substring(start, pos - start);

                WhiteSpaceReader.TryRead(format, ref pos, out string postPadding);
                if (!WhiteSpaceReader.IsRestWhiteSpace(format, pos))
                {
                    pos  = start;
                    unit = Unit <TUnit> .Default;
                    return(PaddedFormat.CreateUnknown(prePadding, format.Substring(start)));
                }

                if (Cache.TryGetUnitForParts(symbolsAndPowers, out unit))
                {
                    Cache.Add(symbol, symbolsAndPowers);
                    Cache.Add(symbol, unit);
                }
                else
                {
                    pos  = start;
                    unit = Unit <TUnit> .Default;
                    return(PaddedFormat.CreateUnknown(prePadding, format.Substring(start)));
                }

                return(new PaddedFormat(prePadding, symbol, postPadding));
            }

            pos = start;
            return(PaddedFormat.CreateUnknown(prePadding, format));
        }