Esempio n. 1
0
        public PkoBpCreditClearedParser(
            ParseHelper parseHelper,
            IRepositoryHelper repositoryHelper,
            PdfReader pdfReader,
            CreditCardPagesExtractor pagesExtractor,
            CreditCardTextParsing ccTextParsing,
            CreditCardClearedTextParsing clearedTextParsing)
        {
            if (parseHelper == null)
                throw new ArgumentNullException("parseHelper");
            if (repositoryHelper == null)
                throw new ArgumentNullException("repositoryHelper");
            if (pdfReader == null)
                throw new ArgumentNullException("pdfReader");
            if (pagesExtractor == null)
                throw new ArgumentNullException("pagesExtractor");
            if (ccTextParsing == null)
                throw new ArgumentNullException("ccTextParsing");
            if (clearedTextParsing == null)
                throw new ArgumentNullException("clearedTextParsing");

            _parseHelper = parseHelper;
            _repositoryHelper = repositoryHelper;
            _pdfReader = pdfReader;
            _pagesExtractor = pagesExtractor;
            _ccTextParsing = ccTextParsing;
            _clearedTextParsing = clearedTextParsing;
        }
Esempio n. 2
0
 public PkoBpParser(ParseHelper parseHelper, IRepositoryHelper repositoryHelper)
 {
     if (parseHelper == null)
         throw new ArgumentNullException("parseHelper");
     _parseHelper = parseHelper;
     if (repositoryHelper == null)
         throw new ArgumentNullException("repositoryHelper");
     _repositoryHelper = repositoryHelper;
 }
Esempio n. 3
0
 public BgzBnpParibasParser(ParseHelper parseHelper, IRepositoryHelper repositoryHelper, IFillOperationFromDescriptionChain fillDescription)
 {
     if (parseHelper == null)
         throw new ArgumentNullException("parseHelper");
     if (repositoryHelper == null)
         throw new ArgumentNullException("repositoryHelper");
     if (fillDescription == null)
         throw new ArgumentNullException("fillDescription");
     _parseHelper = parseHelper;
     _repositoryHelper = repositoryHelper;
     _fillDescription = fillDescription;
 }
Esempio n. 4
0
        public PkoBpCreditCardUnclearedParser(
            ParseHelper parseHelper,
            IRepositoryHelper repositoryHelper,
            CreditCardTextParsing ccTextParsing,
            CreditCardUnclearedTextParsing unclearedParsing)
        {
            if (parseHelper == null)
                throw new ArgumentNullException("parseHelper");
            if (repositoryHelper == null)
                throw new ArgumentNullException("repositoryHelper");
            if (ccTextParsing == null)
                throw new ArgumentNullException("ccTextParsing");
            if (unclearedParsing == null)
                throw new ArgumentNullException("unclearedParsing");

            _parseHelper = parseHelper;
            _repositoryHelper = repositoryHelper;
            _ccTextParsing = ccTextParsing;
            _unclearedParsing = unclearedParsing;
        }
Esempio n. 5
0
        public static bool TryParse(string s, NumberStyles style, IFormatProvider format, out int result)
        {
            Exception e;

            return(ParseHelper.Parse(s, style, format, true, out result, out e));
        }
Esempio n. 6
0
 /// <summary>
 /// 类型转换
 /// </summary>
 /// <typeparam name="T">泛型</typeparam>
 /// <param name="obj">待转换的数据</param>
 /// <param name="defaultValue">转换默认值</param>
 /// <returns>转换后的数据</returns>
 public static T Convert <T>(this object obj, T defaultValue)
 {
     return(ParseHelper.ConvertValue(obj, defaultValue));
 }
Esempio n. 7
0
        internal static bool Parse(string s, bool tryParse, out uint result, out Exception exc)
        {
            uint val = 0;
            int  len;
            int  i;
            bool digits_seen       = false;
            bool has_negative_sign = false;

            result = 0;
            exc    = null;

            if (s == null)
            {
                if (!tryParse)
                {
                    exc = new ArgumentNullException("s");
                }
                return(false);
            }

            len = s.Length;

            char c;

            for (i = 0; i < len; i++)
            {
                c = s[i];
                if (!Char.IsWhiteSpace(c))
                {
                    break;
                }
            }

            if (i == len)
            {
                if (!tryParse)
                {
                    exc = ParseHelper.GetFormatException();
                }
                return(false);
            }

            if (s[i] == '+')
            {
                i++;
            }
            else
            if (s[i] == '-')
            {
                i++;
                has_negative_sign = true;
            }

            for (; i < len; i++)
            {
                c = s[i];

                if (c >= '0' && c <= '9')
                {
                    uint d = (uint)(c - '0');

                    if ((val > MaxValue / 10) || (val == (MaxValue / 10) && d > (MaxValue % 10)))
                    {
                        if (!tryParse)
                        {
                            exc = new OverflowException(String.Format("Value is too large"));
                        }
                        return(false);
                    }
                    val         = (val * 10) + d;
                    digits_seen = true;
                }
                else if (!ParseHelper.ProcessTrailingWhitespace(tryParse, s, i, ref exc))
                {
                    return(false);
                }
            }
            if (!digits_seen)
            {
                if (!tryParse)
                {
                    exc = ParseHelper.GetFormatException();
                }
                return(false);
            }

            // -0 is legal but other negative values are not
            if (has_negative_sign && (val > 0))
            {
                if (!tryParse)
                {
                    exc = new OverflowException(
                        String.Format("Negative number"));
                }
                return(false);
            }

            result = val;
            return(true);
        }
Esempio n. 8
0
        internal static bool Parse(string s, NumberStyles style, IFormatProvider provider, bool tryParse, out uint result, out Exception exc)
        {
            result = 0;
            exc    = null;

            if (s == null)
            {
                if (!tryParse)
                {
                    exc = new ArgumentNullException("s");
                }
                return(false);
            }

            if (s.Length == 0)
            {
                if (!tryParse)
                {
                    exc = ParseHelper.GetFormatException();
                }
                return(false);
            }

            NumberFormatInfo nfi = null;

            if (provider != null)
            {
                Type typeNFI = typeof(NumberFormatInfo);
                nfi = (NumberFormatInfo)provider.GetFormat(typeNFI);
            }
            if (nfi == null)
            {
                nfi = Thread.CurrentThread.CurrentCulture.NumberFormat;
            }

            if (!ParseHelper.CheckStyle(style, tryParse, ref exc))
            {
                return(false);
            }

            bool AllowCurrencySymbol = (style & NumberStyles.AllowCurrencySymbol) != 0;
            bool AllowHexSpecifier   = (style & NumberStyles.AllowHexSpecifier) != 0;
            bool AllowThousands      = (style & NumberStyles.AllowThousands) != 0;
            bool AllowDecimalPoint   = (style & NumberStyles.AllowDecimalPoint) != 0;
            bool AllowParentheses    = (style & NumberStyles.AllowParentheses) != 0;
            bool AllowTrailingSign   = (style & NumberStyles.AllowTrailingSign) != 0;
            bool AllowLeadingSign    = (style & NumberStyles.AllowLeadingSign) != 0;
            bool AllowTrailingWhite  = (style & NumberStyles.AllowTrailingWhite) != 0;
            bool AllowLeadingWhite   = (style & NumberStyles.AllowLeadingWhite) != 0;

            int pos = 0;

            if (AllowLeadingWhite && !ParseHelper.JumpOverWhite(ref pos, s, true, tryParse, ref exc))
            {
                return(false);
            }

            bool foundOpenParentheses = false;
            bool negative             = false;
            bool foundSign            = false;
            bool foundCurrency        = false;

            // Pre-number stuff
            if (AllowParentheses && s[pos] == '(')
            {
                foundOpenParentheses = true;
                foundSign            = true;
                negative             = true; // MS always make the number negative when there parentheses
                // even when NumberFormatInfo.NumberNegativePattern != 0!!!
                pos++;
                if (AllowLeadingWhite && !ParseHelper.JumpOverWhite(ref pos, s, true, tryParse, ref exc))
                {
                    return(false);
                }

                if (s.Substring(pos, nfi.NegativeSign.Length) == nfi.NegativeSign)
                {
                    if (!tryParse)
                    {
                        exc = ParseHelper.GetFormatException();
                    }
                    return(false);
                }
                if (s.Substring(pos, nfi.PositiveSign.Length) == nfi.PositiveSign)
                {
                    if (!tryParse)
                    {
                        exc = ParseHelper.GetFormatException();
                    }
                    return(false);
                }
            }

            if (AllowLeadingSign && !foundSign)
            {
                // Sign + Currency
                ParseHelper.FindSign(ref pos, s, nfi, ref foundSign, ref negative);
                if (foundSign)
                {
                    if (AllowLeadingWhite && !ParseHelper.JumpOverWhite(ref pos, s, true, tryParse, ref exc))
                    {
                        return(false);
                    }
                    if (AllowCurrencySymbol)
                    {
                        ParseHelper.FindCurrency(ref pos, s, nfi, ref foundCurrency);
                        if (foundCurrency && AllowLeadingWhite &&
                            !ParseHelper.JumpOverWhite(ref pos, s, true, tryParse, ref exc))
                        {
                            return(false);
                        }
                    }
                }
            }

            if (AllowCurrencySymbol && !foundCurrency)
            {
                // Currency + sign
                ParseHelper.FindCurrency(ref pos, s, nfi, ref foundCurrency);
                if (foundCurrency)
                {
                    if (AllowLeadingWhite && !ParseHelper.JumpOverWhite(ref pos, s, true, tryParse, ref exc))
                    {
                        return(false);
                    }
                    if (foundCurrency)
                    {
                        if (!foundSign && AllowLeadingSign)
                        {
                            ParseHelper.FindSign(ref pos, s, nfi, ref foundSign, ref negative);
                            if (foundSign && AllowLeadingWhite &&
                                !ParseHelper.JumpOverWhite(ref pos, s, true, tryParse, ref exc))
                            {
                                return(false);
                            }
                        }
                    }
                }
            }

            uint number            = 0;
            int  nDigits           = 0;
            bool decimalPointFound = false;
            uint digitValue;
            char hexDigit;

            // Number stuff
            // Just the same as Int32, but this one adds instead of substract
            do
            {
                if (!ParseHelper.ValidDigit(s[pos], AllowHexSpecifier))
                {
                    if (AllowThousands && ParseHelper.FindOther(ref pos, s, nfi.NumberGroupSeparator))
                    {
                        continue;
                    }
                    else
                    if (!decimalPointFound && AllowDecimalPoint &&
                        ParseHelper.FindOther(ref pos, s, nfi.NumberDecimalSeparator))
                    {
                        decimalPointFound = true;
                        continue;
                    }
                    break;
                }
                else if (AllowHexSpecifier)
                {
                    nDigits++;
                    hexDigit = s[pos++];
                    if (Char.IsDigit(hexDigit))
                    {
                        digitValue = (uint)(hexDigit - '0');
                    }
                    else if (Char.IsLower(hexDigit))
                    {
                        digitValue = (uint)(hexDigit - 'a' + 10);
                    }
                    else
                    {
                        digitValue = (uint)(hexDigit - 'A' + 10);
                    }

                    if (tryParse)
                    {
                        ulong l = number * 16 + digitValue;

                        if (l > MaxValue)
                        {
                            return(false);
                        }
                        number = (uint)l;
                    }
                    else
                    {
                        number = checked (number * 16 + digitValue);
                    }
                }
                else if (decimalPointFound)
                {
                    nDigits++;
                    // Allows decimal point as long as it's only
                    // followed by zeroes.
                    if (s[pos++] != '0')
                    {
                        if (!tryParse)
                        {
                            exc = new OverflowException(String.Format("Value too large or too small."));
                        }
                        return(false);
                    }
                }
                else
                {
                    nDigits++;

                    try
                    {
                        number = checked (number * 10 + (uint)(s[pos++] - '0'));
                    }
                    catch (OverflowException)
                    {
                        if (!tryParse)
                        {
                            exc = new OverflowException(String.Format("Value too large or too small."));
                        }
                        return(false);
                    }
                }
            } while (pos < s.Length);

            // Post number stuff
            if (nDigits == 0)
            {
                if (!tryParse)
                {
                    exc = ParseHelper.GetFormatException();
                }
                return(false);
            }

            if (AllowTrailingSign && !foundSign)
            {
                // Sign + Currency
                ParseHelper.FindSign(ref pos, s, nfi, ref foundSign, ref negative);
                if (foundSign)
                {
                    if (AllowTrailingWhite && !ParseHelper.JumpOverWhite(ref pos, s, true, tryParse, ref exc))
                    {
                        return(false);
                    }
                    if (AllowCurrencySymbol)
                    {
                        ParseHelper.FindCurrency(ref pos, s, nfi, ref foundCurrency);
                    }
                }
            }

            if (AllowCurrencySymbol && !foundCurrency)
            {
                // Currency + sign
                ParseHelper.FindCurrency(ref pos, s, nfi, ref foundCurrency);
                if (foundCurrency)
                {
                    if (AllowTrailingWhite && !ParseHelper.JumpOverWhite(ref pos, s, true, tryParse, ref exc))
                    {
                        return(false);
                    }
                    if (!foundSign && AllowTrailingSign)
                    {
                        ParseHelper.FindSign(ref pos, s, nfi, ref foundSign, ref negative);
                    }
                }
            }

            if (AllowTrailingWhite && pos < s.Length && !ParseHelper.JumpOverWhite(ref pos, s, false, tryParse, ref exc))
            {
                return(false);
            }

            if (foundOpenParentheses)
            {
                if (pos >= s.Length || s[pos++] != ')')
                {
                    if (!tryParse)
                    {
                        exc = ParseHelper.GetFormatException();
                    }
                    return(false);
                }
                if (AllowTrailingWhite && pos < s.Length && !ParseHelper.JumpOverWhite(ref pos, s, false, tryParse, ref exc))
                {
                    return(false);
                }
            }

            if (pos < s.Length && s[pos] != '\u0000')
            {
                if (!tryParse)
                {
                    exc = ParseHelper.GetFormatException();
                }
                return(false);
            }

            // -0 is legal but other negative values are not
            if (negative && (number > 0))
            {
                if (!tryParse)
                {
                    exc = new OverflowException(
                        String.Format("Negative number"));
                }
                return(false);
            }

            result = number;

            return(true);
        }