You can use polymorphism to get the varying behavior of these objects.

One simple way to do it is this:

package Packet;

my %patterns;    # could add some in declaration

sub addType {
    my $regex     = shift;
    my $className = shift;
    $patterns{$className} = $regex;
}

sub removeType {
    my $className = shift;
    delete $patterns{$className};
}

sub makeOnePacket {

    # get a packet
    my $packet = getAPacket();
    return undef unless $packet;
    my $newObject;
    my ( $className, $regex );
    while ( ( $className, $regex ) = each(%patterns) ) {
        my @fields;

        if ( @fields = ( $packet =~ $regex ) ) {
            $newObject = $className->new( $packet, @fields );
            last;
        }
    }
    $newObject;
}

# These two must be defined by classes that want
# to work with this system.

sub newFromPacket {
    my $class  = shift;
    my $packet = shift;
    my @fields = @_;

    # initialize as needed, return object.
    bless { packet => $packet, fields => \@fields }, $class;
}

sub process {
    my $self = shift;

    # now do whatever is necessary
}

package main;

Packet::addType( qr/^(abc)(.*)/, 'SomeType' );
Packet::addType( qr/^(def)(.*)/, 'SomeOtherType' );

while ( my $newPacket = makeOnePacket() ) {
    $newPacket->process();
}
[download]

Note that now you can add new packages that work with this system by just including them. Stick the following in NewPacket.pm:

package NewPacket;
use Packet;

# Could have inherited from Packet, but no
# reason to. Luckily, this isn't Java or C++.
sub newFromPacket {
    my $class  = shift;
    my $packet = shift;
    my @fields = @_;

    # initialize as needed, return object.
    bless { packet => $packet, fields => \@fields }, $class;
}

sub process {
    my $self = shift;
}

# you could also use __PACKAGE__ here:
Packet::addType( qr/^(something)(.*)/,     'NewPacket' );
Packet::addType( qr/^(somethingElse)(.*)/, 'NewPacket' );    # returns
+ true
[download]

Then a simple use NewPacket; in your main will add the new functionality.

update: added explanation about adding new types.

But that is all that is gained by all that, being able to plug in extra parsers without restarting. Usually that's not needed... I usually only do it in the case of network bots that have to interact with users. Generally, it's best to just stick to the exact methodologies used in the "perltoot" Perl documentation. If you don't see it in there, it's probably a sign to rethink the implementation.

Another important thing is, I don't see a use strict or a use warnings. Probably you just trimmed that part to make your post concise, but you need to include those so we know that you're not just digging holes for yourself. Without strict mode and warnings, there is no salvation.

My OO - fu is a bit weak, the only two objects that need to be objects in the examples below are the packets (which I use to unpack/pack the binary stream) and the packet engines (which maintain state, sockets and other neat stuff). The tally and function objects may as well be straight functions, but if you're going OO, you may as well go the whole hog.

As near as I can tell the goal of OO is to combine data and code, so anytime you see data, you want to attach code to it. Thus the packets should be objects, and so should the engines. Otherwise you just have modular code, i.e. modules, which perl already does fine. This approach also minimises your packet variables, and notice - no true globals.

---Broad outline:
Get packets
Tally stats
Mangle them
Tally stats
Send 'em out


B---road outline, 10x magnification:
Get packets from packet engine
Run them through the tally object
Mangle packets with custom packet mangler (TM)
Tally object...
Send them out through the packet engine

---Broad outline, 100x mag:
foreach $packet_engine ( @all_packet_engines ) {
 push @incoming_packet_queue, $packet_engine_object->get_packets;
}

$stats_object->tally(@incoming_packet_queue);

@outgoing_packet_queue = $function_object->mangle(@incoming_packet_que
+ue);
@incoming_packet_queue = ();

$stats_object->tally(@outgoing_packet_queue);

foreach $packet ( @outgoing_packet_queue ) {
 #insert clever routing logic for packets e.g.
 foreach $engine ( @all_packet_engines ) {
 if ( $packet->{ATTRIB} == $engine->{ATTRIB} ) {$engine->send($packet)
+}
 }
}
[download]

now all you have to do is fill in the thousands of lines of code for each object. It's 3am, so maybe it's not so clear. Read up on ipchains for the idea I'm working with here.

To make it more like ipchains, you would have multiple function objects (or multiple routines in the function object), and allow the objects(functions) to pass the packet to each other. Each function would mangle the packet until one of them passed it to the output routing object.

____________________
Jeremy
I didn't believe in evil until I dated it.