format.pm

Astercon2 开源软交换 2.2.0

package Number::Format;

# Due to differences in the locale system Perl 5.8 is required for
# this module to function properly.  You may be able to get it to work
# on older Perls by uncommenting this line, but it is not supported.
# I recommend you either upgrade Perl or download an older version of
# this module in that case.
require 5.008;

=head1 NAME

Number::Format - Perl extension for formatting numbers

=head1 SYNOPSIS

  use Number::Format;
  my $x = new Number::Format %args;
  $formatted = $x->round($number, $precision);
  $formatted = $x->format_number($number, $precision, $trailing_zeroes);
  $formatted = $x->format_negative($number, $picture);
  $formatted = $x->format_picture($number, $picture);
  $formatted = $x->format_price($number, $precision);
  $formatted = $x->format_bytes($number, $precision);
  $number    = $x->unformat_number($formatted);

  use Number::Format qw(:subs);
  $formatted = round($number, $precision);
  $formatted = format_number($number, $precision, $trailing_zeroes);
  $formatted = format_negative($number, $picture);
  $formatted = format_picture($number, $picture);
  $formatted = format_price($number, $precision);
  $formatted = format_bytes($number, $precision);
  $number    = unformat_number($formatted);

=head1 REQUIRES

Perl, version 5.8 or higher.

POSIX.pm to determine locale settings.

Carp.pm is used for some error reporting.

=head1 DESCRIPTION

These functions provide an easy means of formatting numbers in a
manner suitable for displaying to the user.

There are two ways to use this package.  One is to declare an object
of type Number::Format, which you can think of as a formatting engine.
The various functions defined here are provided as object methods.
The constructor C<new()> can be used to set the parameters of the
formatting engine.  Valid parameters are:

  THOUSANDS_SEP     - character inserted between groups of 3 digits
  DECIMAL_POINT     - character separating integer and fractional parts
  MON_THOUSANDS_SEP - like THOUSANDS_SEP, but used for format_price
  MON_DECIMAL_POINT - like DECIMAL_POINT, but used for format_price
  INT_CURR_SYMBOL   - character(s) denoting currency (see format_price())
  DECIMAL_DIGITS    - number of digits to the right of dec point (def 2)
  DECIMAL_FILL      - boolean; whether to add zeroes to fill out decimal
  NEG_FORMAT        - format to display negative numbers (def ``-x'')
  KILO_SUFFIX       - suffix to add when format_bytes formats kilobytes
  MEGA_SUFFIX       -    "    "  "    "        "         "    megabytes
  GIGA_SUFFIX       -    "    "  "    "        "         "    gigabytes

They may be specified in upper or lower case, with or without a
leading hyphen ( - ).

If C<THOUSANDS_SEP> is set to the empty string, format_number will not
insert any separators.

The defaults for C<THOUSANDS_SEP>, C<DECIMAL_POINT>,
C<MON_THOUSANDS_SEP>, C<MON_DECIMAL_POINT>, and C<INT_CURR_SYMBOL>
come from the POSIX locale information (see L<perllocale>).  If your
POSIX locale does not provide C<MON_THOUSANDS_SEP> and/or
C<MON_DECIMAL_POINT> fields, then the C<THOUSANDS_SEP> and/or
C<DECIMAL_POINT> values are used for those parameters.  Formerly,
POSIX was optional but this caused problems in some cases, so it is
now required.  If this causes you hardship, please contact the author
of this package at <[e-mail]> (remove "SPAM" to get correct
email address) for help.

If any of the above parameters are not specified when you invoke
C<new()>, then the values are taken from package global variables of
the same name (e.g.  C<$DECIMAL_POINT> is the default for the
C<DECIMAL_POINT> parameter).  If you use the C<:vars> keyword on your
C<use Number::Format> line (see non-object-oriented example below) you
will import those variables into your namesapce and can assign values
as if they were your own local variables.  The default values for all
the parameters are:

  THOUSANDS_SEP     = ','
  DECIMAL_POINT     = '.'
  MON_THOUSANDS_SEP = ','
  MON_DECIMAL_POINT = '.'
  INT_CURR_SYMBOL   = 'USD'
  DECIMAL_DIGITS    = 2
  DECIMAL_FILL      = 0
  NEG_FORMAT        = '-x'
  KILO_SUFFIX       = 'K'
  MEGA_SUFFIX       = 'M'
  GIGA_SUFFIX       = 'G'

Note however that when you first call one of the functions in this
module I<without> using the object-oriented interface, further setting
of those global variables will have no effect on non-OO calls.  It is
recommended that you use the object-oriented interface instead for
fewer headaches and a cleaner design.

The C<DECIMAL_FILL> and C<DECIMAL_DIGITS> values are not set by the
Locale system, but are definable by the user.  They affect the output
of C<format_number()>.  Setting C<DECIMAL_DIGITS> is like giving that
value as the C<$precision> argument to that function.  Setting
C<DECIMAL_FILL> to a true value causes C<format_number()> to append
zeroes to the right of the decimal digits until the length is the
specified number of digits.

C<NEG_FORMAT> is only used by C<format_negative()> and is a string
containing the letter 'x', where that letter will be replaced by a
positive representation of the number being passed to that function.
C<format_number()> and C<format_price()> utilize this feature by
calling C<format_negative()> if the number was less than 0.

C<KILO_SUFFIX>, C<MEGA_SUFFIX>, and C<GIGA_SUFFIX> are used by
C<format_bytes()> when the value is over 1024, 1024*1024, or
1024*1024*1024, respectively.  The default values are "K", "M", and
"G".  Note: we can not do TERA because of integer overflows on 32-bit
systems.

The only restrictions on C<DECIMAL_POINT> and C<THOUSANDS_SEP> are that
they must not be digits, must not be identical, and must each be one
character.  There are no restrictions on C<INT_CURR_SYMBOL>.

For example, a German user might include this in their code:

  use Number::Format;
  my $de = new Number::Format(-thousands_sep   => '.',
                              -decimal_point   => ',',
                              -int_curr_symbol => 'DEM');
  my $formatted = $de->format_number($number);

Or, if you prefer not to use the object oriented interface, you can do
this instead:

  use Number::Format qw(:subs :vars);
  $THOUSANDS_SEP   = '.';
  $DECIMAL_POINT   = ',';
  $INT_CURR_SYMBOL = 'DEM';
  my $formatted = format_number($number);

=head1 EXPORTS

Nothing is exported by default.  To export the functions or the global
variables defined herein, specify the function name(s) on the import
list of the C<use Number::Format> statement.  To export all functions
defined herein, use the special tag C<:subs>.  To export the
variables, use the special tag C<:vars>; to export both subs and vars
you can use the tag C<:all>.

=cut

###---------------------------------------------------------------------

use strict;
use Exporter;
use Carp;
use POSIX;

our @ISA     = qw(Exporter);

our @EXPORT_SUBS = qw(format_number format_negative format_picture
                      format_price format_bytes round unformat_number);
our @EXPORT_VARS = qw($DECIMAL_DIGITS $DECIMAL_FILL $DECIMAL_POINT
                      $DEFAULT_LOCALE $INT_CURR_SYMBOL $KILO_SUFFIX
                      $MEGA_SUFFIX $GIGA_SUFFIX $NEG_FORMAT $THOUSANDS_SEP);
our @EXPORT_OK   = (@EXPORT_SUBS, @EXPORT_VARS);
our %EXPORT_TAGS = (subs => \@EXPORT_SUBS,
                    vars => \@EXPORT_VARS,
                    all  => [ @EXPORT_SUBS, @EXPORT_VARS ]);

our $VERSION = '1.52';

our $DECIMAL_POINT   = '.';
our $THOUSANDS_SEP   = ',';
our $INT_CURR_SYMBOL = 'USD';
our $DECIMAL_DIGITS  = 2;
our $DECIMAL_FILL    = 0;
our $NEG_FORMAT      = '-x';
our $KILO_SUFFIX     = 'K';
our $MEGA_SUFFIX     = 'M';
our $GIGA_SUFFIX     = 'G';

our $DEFAULT_LOCALE = { (mon_thousands_sep => $THOUSANDS_SEP,
                         mon_decimal_point => $DECIMAL_POINT,
                         thousands_sep     => $THOUSANDS_SEP,
                         decimal_point     => $DECIMAL_POINT,
                         int_curr_symbol   => $INT_CURR_SYMBOL,
                         neg_format        => $NEG_FORMAT,
                         kilo_suffix       => $KILO_SUFFIX,
                         mega_suffix       => $MEGA_SUFFIX,
                         giga_suffix       => $GIGA_SUFFIX,
                         decimal_digits    => $DECIMAL_DIGITS,
                         decimal_fill      => $DECIMAL_FILL,
                        ) };

###---------------------------------------------------------------------

# INTERNAL FUNCTIONS

# These functions (with names beginning with '_' are for internal use
# only.  There is no guarantee that they will remain the same from one
# version to the next!

##----------------------------------------------------------------------

# _get_self creates an instance of Number::Format with the default
#     values for the configuration parameters, if the first element of
#     @_ is not already an object.

my $DefaultObject;
sub _get_self
{
    unless (ref $_[0])
    {
        $DefaultObject ||= new Number::Format();
        unshift (@_, $DefaultObject);
    }
    @_;
}

##----------------------------------------------------------------------

# _check_seps is used to validate that the thousands_sep and
#     decimal_point variables have acceptable values.  For internal use
#     only.

sub _check_seps
{
    my ($self) = @_;
    croak "Not an object" unless ref $self;
    croak "Number::Format: {thousands_sep} is undefined\n"
        unless defined $self->{thousands_sep};
    croak "Number::Format: {thousands_sep} is too long (max 1 character)\n"
        if length $self->{thousands_sep} > 1;
    croak "Number::Format: {thousands_sep} may not be numeric\n"
        if $self->{thousands_sep} =~ /\d/;
    croak "Number::Format: {decimal_point} must be one character\n"
        if length $self->{decimal_point} != 1;
    croak "Number::Format: {decimal_point} may not be numeric\n"
        if $self->{decimal_point} =~ /\d/;
    croak("Number::Format: {thousands_sep} and {decimal_point} ".
          "may not be equal\n")
        if $self->{decimal_point} eq $self->{thousands_sep};
}

###---------------------------------------------------------------------

=head1 METHODS

=over 4

=cut

##----------------------------------------------------------------------

=item new( %args )

Creates a new Number::Format object.  Valid keys for %args are any of
the parameters described above.  Keys may be in all uppercase or all
lowercase, and may optionally be preceded by a hyphen (-) character.
Example:

  my $de = new Number::Format(-thousands_sep   => '.',
                              -decimal_point   => ',',
                              -int_curr_symbol => 'DEM');

=cut

sub new
{
    my $type = shift;
    my %args = @_;

    # Fetch defaults from current locale, or failing that, using globals
    my $me            = {};
    my $locale        = setlocale(LC_ALL);
    my $locale_values = localeconv();
    my $arg;
    foreach $arg (keys %$locale_values)
    {
        $me->{$arg} = $locale_values->{$arg};
    }
    $me->{mon_decimal_point} ||= $DECIMAL_POINT;
    $me->{mon_thousands_sep} ||= $THOUSANDS_SEP;
    $me->{int_curr_symbol}   ||= $INT_CURR_SYMBOL;
    $me->{decimal_digits}    ||= $DECIMAL_DIGITS;
    $me->{decimal_fill}      ||= $DECIMAL_FILL;
    $me->{neg_format}        ||= $NEG_FORMAT;
    $me->{kilo_suffix}       ||= $KILO_SUFFIX;
    $me->{mega_suffix}       ||= $MEGA_SUFFIX;
    $me->{giga_suffix}       ||= $GIGA_SUFFIX;
    $me->{thousands_sep}     ||= $me->{mon_thousands_sep};