src/Utilities/Message.pm

=head1 NAME

Utilities::Message - Hold a multi level message that can be reconstructed to any level.

=head1 SYNOPSIS

        my $obj = Utilities::Message->new();

=head1 DESCRIPTION

Hold a multi level message that can be reconstructed to any level.

=head1 METHODS

=over

=cut

=item C<new()>

   A new Message object.
   
=item C<setlevel([level_number])>

   Set the current level to which messages can be assigned.

=item C<message(string)>

   Set a new message at the current level.

=item C<read([level])>

   Return list of all messages up to level n (or current assignment level).
   
=item C<readlevel(level)>

   Read only those messages assigned to the given level.

=item C<copy(Message)>

   Copy the messages from one object to the current,
   starting at the current active level.
   
=item C<levels()>

   Return the number of assignment levels.

=back

=head1 AUTHOR

Originally Written by Christopher Williams.
   
=head1 MAINTAINER

Shaun ASHBY 

=cut

BEGIN
   {
   die __PACKAGE__.": I AM still used!!","\n";
   };

package Utilities::Message;
require 5.004;

sub new {
        my $class=shift;
        $self={};
        bless $self, $class;
        $self->{max}=0;
        $self->setlevel(0);
        $self->{messages}=();
        return $self;
}

sub setlevel {
        my $self=shift;
                
        if ( @_ ) {
          $self->{aslevel}=shift
        }
        else {
          $self->{aslevel}++;
        }
        if ( $self->{aslevel} > $self->{max} ) { $self->{max}++ }
}

sub levels {
        my $self=shift;
        return $self->{max};
}

sub message {
        my $self=shift;
        my $message=shift;

        push @{$self->{messages}}, $message;
        push @{$self->{messagelevel}}, $self->{aslevel};
}
 
sub read {
        my $self=shift;

        my $lev;
        if (@_) { $lev=shift }
        else { $lev=$self->{aslevel} }
        my @messages=();
        for ( my $i=0; $i<=$#{$self->{messages}}; $i++) {
         if ( $self->{messagelevel}[$i] <= $lev ) {
            push @messages, $self->{messages}[$i];
         }
        }
        return @messages;
}

sub readlevel {
        my $self=shift;

        my @messages=();
        my $lev;
        if (@_) { $lev=shift }
        else { $lev=$self->{aslevel} }

        for ( my $i=0; $i<=$#{$self->{messages}}; $i++) {
         if ( $self->{messagelevel}[$i] eq $lev ) {
            push @messages, $self->{messages}[$i];
         }
        }
        return @messages;
}

sub copy {
        my $self=shift;
        my $obj=shift;

        my $currentlev=$self->{aslevel};
        for ( my $i=0; $i<=$obj->levels(); $i++) {
          foreach $mes ( $obj->readlevel($i) ) {
            $self->message($mes);
          }
          $self->setlevel();
        }
        $self->setlevel($currentlev);
}

Revision:	1.5
Committed:	Tue Feb 27 11:59:50 2007 UTC (18 years, 2 months ago) by sashby
Content type:	text/plain
Branch:	MAIN
Changes since 1.4:	+5 -0 lines
Log Message:	Merged from XML branch to HEAD. Start release prep.
#	User	Rev	Content
1	sashby	1.3	=head1 NAME
2
3			Utilities::Message - Hold a multi level message that can be reconstructed to any level.
4
5			=head1 SYNOPSIS
6
7			my $obj = Utilities::Message->new();
8
9			=head1 DESCRIPTION
10
11			Hold a multi level message that can be reconstructed to any level.
12
13			=head1 METHODS
14
15			=over
16
17			=cut
18
19			=item C<new()>
20
21			A new Message object.
22
23			=item C<setlevel([level_number])>
24
25			Set the current level to which messages can be assigned.
26
27			=item C<message(string)>
28
29			Set a new message at the current level.
30
31			=item C<read([level])>
32
33			Return list of all messages up to level n (or current assignment level).
34
35			=item C<readlevel(level)>
36
37			Read only those messages assigned to the given level.
38
39			=item C<copy(Message)>
40
41			Copy the messages from one object to the current,
42			starting at the current active level.
43
44			=item C<levels()>
45
46			Return the number of assignment levels.
47
48			=back
49
50			=head1 AUTHOR
51
52			Originally Written by Christopher Williams.
53
54			=head1 MAINTAINER
55
56	sashby	1.4	Shaun ASHBY
57	sashby	1.3
58			=cut
59	williamc	1.1
60	sashby	1.5	BEGIN
61			{
62			die __PACKAGE__.": I AM still used!!","\n";
63			};
64
65	williamc	1.1	package Utilities::Message;
66			require 5.004;
67
68			sub new {
69			my $class=shift;
70			$self={};
71			bless $self, $class;
72	williamc	1.2	$self->{max}=0;
73	williamc	1.1	$self->setlevel(0);
74			$self->{messages}=();
75			return $self;
76			}
77
78			sub setlevel {
79			my $self=shift;
80
81	williamc	1.2	if ( @_ ) {
82			$self->{aslevel}=shift
83			}
84			else {
85			$self->{aslevel}++;
86			}
87	williamc	1.1	if ( $self->{aslevel} > $self->{max} ) { $self->{max}++ }
88			}
89
90			sub levels {
91			my $self=shift;
92			return $self->{max};
93			}
94
95			sub message {
96			my $self=shift;
97			my $message=shift;
98
99			push @{$self->{messages}}, $message;
100			push @{$self->{messagelevel}}, $self->{aslevel};
101			}
102
103			sub read {
104			my $self=shift;
105
106			my $lev;
107			if (@_) { $lev=shift }
108			else { $lev=$self->{aslevel} }
109			my @messages=();
110			for ( my $i=0; $i<=$#{$self->{messages}}; $i++) {
111			if ( $self->{messagelevel}[$i] <= $lev ) {
112			push @messages, $self->{messages}[$i];
113			}
114			}
115			return @messages;
116			}
117
118			sub readlevel {
119			my $self=shift;
120
121			my @messages=();
122			my $lev;
123			if (@_) { $lev=shift }
124			else { $lev=$self->{aslevel} }
125
126			for ( my $i=0; $i<=$#{$self->{messages}}; $i++) {
127			if ( $self->{messagelevel}[$i] eq $lev ) {
128			push @messages, $self->{messages}[$i];
129			}
130			}
131			return @messages;
132			}
133
134			sub copy {
135			my $self=shift;
136			my $obj=shift;
137
138			my $currentlev=$self->{aslevel};
139			for ( my $i=0; $i<=$obj->levels(); $i++) {
140			foreach $mes ( $obj->readlevel($i) ) {
141			$self->message($mes);
142			}
143			$self->setlevel();
144			}
145			$self->setlevel($currentlev);
146			}
147