Esempio n. 1
0
        internal string ConvertToLocalizedText(Decimal num)
        {
            StringBuilder  text  = new StringBuilder();
            StackWithIndex stack = new StackWithIndex();

            if (num < new Decimal(0))
            {
                text.Append(this.Minus);
                num = Math.Abs(num);
            }
            num = this.Initialize(num);
            if ((long)(ulong)num == 0L)
            {
                text.Append(this.Zero);
            }
            else
            {
                this.GetIntegralStack(Math.Truncate(num), 1UL, stack);
                this.ConvertIntergralStackToText(stack, text);
            }
            num -= Math.Truncate(num);
            if (num != new Decimal(0))
            {
                text.Append(this.DecimalPoint);
                this.GetDecimalText(num, text);
            }
            return(text.ToString());
        }
Esempio n. 2
0
        protected override void ConvertIntergralStackToText(StackWithIndex stack, StringBuilder text)
        {
            string str1 = string.Empty;
            bool   flag = true;

            while (stack.Count > 0)
            {
                string str2 = stack.Pop();
                if (str2 == this.Zero)
                {
                    if (!flag)
                    {
                        str1 = this.Zero;
                    }
                    flag = true;
                }
                else if (str2 == this.TenThousand || str2 == this.HundredMillion || str2 == this.ThousandBillion)
                {
                    text.Append(str2);
                    str1 = string.Empty;
                    flag = false;
                }
                else if (!string.IsNullOrEmpty(str2))
                {
                    text.Append(str1);
                    text.Append(str2);
                    str1 = string.Empty;
                    flag = false;
                }
            }
        }
Esempio n. 3
0
 protected override void ConvertIntergralStackToText(StackWithIndex stack, StringBuilder text)
 {
     while (stack.Count > 0)
     {
         string str = stack.Pop();
         text.Append(str);
     }
 }
Esempio n. 4
0
 protected override void ConvertIntergralStackToText(StackWithIndex stack, StringBuilder text)
 {
     while (stack.Count > 0 && stack.Peek() == this.Zero)
     {
         stack.Pop();
     }
     while (stack.Count > 0)
     {
         text.Append(stack.Pop());
     }
 }
Esempio n. 5
0
        protected override void ConvertIntergralStackToText(StackWithIndex stack, StringBuilder text)
        {
            while (stack.Count > 0)
            {
                string str = stack.Pop();
                text.Append(str);
            }

            if ((int)text[text.Length - 1] != 32)
            {
                return;
            }
            text.Remove(text.Length - 1, 1);
        }
Esempio n. 6
0
        protected override void ConvertIntergralStackToText(StackWithIndex stack, StringBuilder text)
        {
            while (stack.Count > 0 && string.IsNullOrEmpty(stack.Peek()))
            {
                stack.Pop();
            }
            bool flag = false;

            if (stack.Peek().Equals(this.Digits[1]))
            {
                for (int index = 2; index < stack.Count && string.IsNullOrEmpty(stack[index]); ++index)
                {
                    if (index == stack.Count - 1)
                    {
                        flag = true;
                    }
                }
            }
            else
            {
                flag = false;
            }

            while (stack.Count > 0)
            {
                string str = stack.Pop();
                if (!string.IsNullOrEmpty(str))
                {
                    if (flag)
                    {
                        flag = false;
                    }
                    else if (!str.StartsWith(this.Digits[1]) || !str.EndsWith(this.Ten) && !str.EndsWith(this.Hundred) && !str.EndsWith(this.Thousand))
                    {
                        text.Append(str);
                    }
                    else
                    {
                        text.Append(str.Substring(this.Digits[1].Length));
                    }
                }
            }

            if ((int)text[text.Length - 1] != 32)
            {
                return;
            }
            text.Remove(text.Length - 1, 1);
        }
Esempio n. 7
0
 /// <summary>
 /// Splits the number.
 /// Pushs every digit and its digitWeight into stack.
 /// </summary>
 /// <param name="num">the number needed to be splited.</param>
 /// <param name="position">Splits the number from this position.</param>
 /// <param name="stack">Pushs every digit and its digitWeight this stack.</param>
 protected virtual void GetIntegralStack(Decimal num, ulong position, StackWithIndex stack)
 {
     if (num < new Decimal(10000))
     {
         if (num != new Decimal(0) || (long)position == 1000000000000L)
         {
             stack.Push(this.GetPositionText(position));
         }
         for (int index = 0; index < 4; ++index)
         {
             int   digit     = (int)(num % new Decimal(10));
             ulong position1 = (ulong)Math.Pow(10.0, (double)index);
             num /= new Decimal(10);
             stack.Push(this.GetDigitText(digit, position1));
         }
     }
     else
     {
         this.GetIntegralStack(Math.Truncate(num % new Decimal(10000)), position, stack);
         this.GetIntegralStack(Math.Truncate(num / new Decimal(10000)), position * 10000UL, stack);
     }
 }
Esempio n. 8
0
 /// <summary>
 /// Converts the digit information from the stack into a StringBuilder.
 /// </summary>
 /// <param name="stack">Stores the digits needed to be transfered.</param>
 /// <param name="text">Transfers the digits to this text.</param>
 protected abstract void ConvertIntergralStackToText(StackWithIndex stack, StringBuilder text);