# reworked slightly, for conciseness.
sub new
{
  my %self;
  ( my $class, $self{qw( from_node to_node label )} ) = @_;
  bless \%self, $class;
}
[download]

sub new
{
  @_ == 2 and die "Error: can't set just one of the links!";
  my %self;
  ( my $class, $self{qw( from_node to_node label )} ) = @_;
  bless \%self, $class;
}
[download]

sub new
{
  my %self;
  ( my $class, $self{qw( from_node to_node label )} ) = @_;
  $self{'from_node'} && ! $self{'to_node'} and
    die "Error: can't set just one of the links!";
  bless \%self, $class;
}
[download]

jdporter
The 6th Rule of Perl Club is -- There is no Rule #6.

The normal Perl idiom is to use named parameters and create a hash. Something like this:

package Edge;
sub new {
    my ($class, %param) = @_;
    bless {
        map { $_ => $param{$_} } qw(from_node to_node label)
    }, $class;
};

use Data::Dumper;
print Dumper(Edge->new);
print Dumper(Edge->new(from_node => 'foo', to_node => 'bar'));
print Dumper(Edge->new(from_node => 'foo', to_node => 'bar', label => 
+'ni'));

__END__
Produces:
$VAR1 = bless( {
                 'to_node' => undef,
                 'from_node' => undef,
                 'label' => undef
               }, 'Edge' );
$VAR1 = bless( {
                 'to_node' => 'bar',
                 'from_node' => 'foo',
                 'label' => undef
               }, 'Edge' );
$VAR1 = bless( {
                 'to_node' => 'bar',
                 'from_node' => 'foo',
                 'label' => 'ni'
               }, 'Edge' );
[download]

This gives you extra flexibility since you do not tie yourself down to a specific number or order of parameters. In Perl6 it will even be efficient :-)

{
  ## accepted attributes
  my %options = map { $_ => undef } qw/ from_node to_node label /;
  sub new {
    my $class = shift;
    bless {
      %options,
      map { exists $options{$_} ? ( $_ => 1 ) : () } @_
    }, $class
  }
}
[download]

_________
broquaint

update: code complies with OP request

Before you proceed with writing a no-argument new() constructor, consider whether an unconnected edge object would by semantically valid in your system. If not, drop that constructor.

When you can construct a system such that no object is ever in a semantically invalid state between method invocations, the system is a lot easier to test, and a lot more robust.

That said, an optional trailing parameter is easy to handle.

sub new {
    my $class = shift;
    my($from, $to, $label) = @_;
    my $self = {};
    $self->{'from_node'} = $from;
    $self->{'to_node'} = $to;
    $self->{'label'} = $label;   # which may be undef
    bless $self, $class;
}
[download]

This is less code than the named argument forms that other people are suggesting, but is also less flexible should you decide to support other edge attributes that can be set at construction time.

However, you are free to inspect the arguments to subroutines, and do different things based on the number of arguments. Arguments are found in @_, using an array in scalar context gives you the number of elements, and Perl has an if-then-elsif-else construct, which gives you all the building blocks to do what you want.

Abigail

Or if you are lazy, just grab Class::Multimethods. It presents a solution that is more open-closed than using an if-then-elsif-else. For example: you can add multi methods to the subclass without touching the superclass.

package Edge;


use vars qw(%FIELDS);
# Define class properties
use fields qw(from_node to_node label);

{
     # Default values for class properties 
     my $_def_values = { from_node => undef,
                         to_node   => undef,
                         label     => undef,
                       };
     
     sub _class_def { $_def_values; }
}

# Constractor
sub new {
     my $proto = shift;
     my $class = ref($proto) || $proto;      
     
     # Define default values for object instance
     my $defaults = ref($proto) ? $proto : $class->_class_def();   
     my $self = {};
     
     for(keys %$defaults) { $self->{$_} = $defaults->{$_}      }      
+            
     bless $self, $class;      
     $self->_init(@_) if @_;    
     return $self;
}

# Initialization of object
sub _init {
     my $self = shift;
     my %params = @_;
     for my $par(keys %params) {
         $self->{$par} = $params{$par} if exists $FIELDS{$par};
     }
}
[download]

      
--------------------------------
SV* sv_bless(SV* sv, HV* stash);

I've already spoken on the problem I have with your ref($proto) stuff.

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

Thanks for correction. Maybe you are right. My experiense is not enough for confirmation or refutation your assertion. I use a book 'Object Oriented Perl' by Damian Conway and there are two ways to do a clon of existing object (p. 104). In my mind, for person, who use some class, it's easier to call one method new() for creation or copy of an object intead of calling separate methods for this.

      
--------------------------------
SV* sv_bless(SV* sv, HV* stash);