package Mine::Openview::opcmsg;

use strict;
use warnings;

sub new {
    my $class = shift;
    my %params = @_;
    my $self  = \%params;
    return bless $self, $class;
}

sub send {
  my $self = shift;
# Setup arguments for opcmsg command.  If the syntax 
# changes this is were you'll apply the changes.
    my $cmd = "opcmsg". 
        " msg_text=".$self->{cmd}.
        " application=".$self{app}.
        " object=".$self->{obj}.
        " severity=".$self->{sev}.
        " msg_grp=".$self->{msgg}.
        " service_id=".$self->{ser};

    return $cmd;
}

1;
[download]

That would allow you to access the module variables like this:

..in module..
sub somefunction
{
   my $self = shift;
   my $msg = $self->{msg};
}
[download]

I.e. it makes the hash %params which contains your parameters the basis for the object you're creating - it then contains all the values you've passed to the constructor.

Pass your data to new() (the constructor) as a hash ref.

#!/bin/perl5

use strict;
use warnings;
use Data::Dumper;

#use lib '/home/nhwatson/lib/perl/';
use Mine::Openview::opcmsg;

my $ovs = Mine::Openview::opcmsg->new(
 {
    msg => 'This is a test',
    app => 'Perl script',
    obj => 'Perl module',
    sev => 'warning',
    msgg => 'message group',
    ser => 'service ID',
  }
);

#die Dumper $ovs;

my $return = $ovs->send;

print "\nreturn = " . $return . "\n";
[download]

package Mine::Openview::opcmsg;

use strict;
use warnings;

sub new {
    my $class = shift;
    my $self  = shift;
    return bless $self, $class;
}

sub send {
  
  my $self = shift;

  my $cmd = join "\n",
    "opcmsg",
    "msg_text = " . $self->{msg},
    "application = " . $self->{app},
    "object = " . $self->{obj},
    "severity = ".$self->{sev},
    "msg_grp = " . $self->{msgg},
    "service_id = " . $self->{ser};
  
  return $cmd;
}

1;
[download]

---------- Capture Output ----------
> "C:\Perl\bin\perl.exe" monk.pl

return = opcmsg
msg_text = This is a test
application = Perl script
object = Perl module
severity = warning
msg_grp = message group
service_id = service ID

> Terminated with exit code 0.
[download]

Thanks. It makes more sense now. Thanks to dorward also for the perldoc reference.

Neil Watson
watson-wilson.ca

You shift a bunch of data into various variables in the main body of the module...

... but you pass those bits of data into the new() method which doesn't do anything with them.

Take a look at the section on Constructors and Instance Methods in perltoot.

If I put the shifts into the new() method.

sub new {
    my $class = shift;
    my $self  = {};

# Get message strings from subroutine call
$msg  = shift; # message text
$app  = shift; # application label
$obj  = shift; # object
$sev  = shift; # severity of message 
$msgg = shift; # message group
$ser  = shift; # service id

    return bless $self, $class; 
}
[download]

The data still goes missing.

Neil Watson
watson-wilson.ca

Given the use strict that code won't compile, so one presumes that you still have my $msg = shift; etc. That means that those variables are scoped to the new sub and disappear after it returns. You want to store the values off in your instance and then retrieve them from there later.

package Foo;

sub new {
  my $class = shift;
  my %self = @_;

  return bless \%self, $class;
}

sub do_something {
  my $self = shift;

  print "msg is: ", $self->{msg}, "\n";
}

## Meanwhile, back on the ranch . . . erm, in the main package
package main;

my $foo = Foo->new( msg => "WUBBA WUBBA" );

$foo->do-something;
[download]

Those scalars drop out of scope and are lost. You should store the values in the $self hashref ... as the example I referenced previously shows.

Maybe you will want to take a look at this document too.