--
Andrew Gaffney
Network Administrator
Skyline Aeronautics, LLC.

Generally you are correct, though there is a little "and then in step 3
black magic happens and..." to your answer.

Presumably the 'use DBI' is still in the top of the personal module. It
must be somewhere (obviously), and that is generally where it would go.
In this case the module is accessing the DBI functions, so 'use DBI'
goes at the top of the module, then the script is accessing the MyModule
functions, so 'use MyModule' goes at the top of the script... but, Perl
has only one @INC/%INC, so once a library is loaded... it is loaded.
This allows you to get away with a few coding problems, specifically you
may load and access a library in one module, then load a second that
accesses the library's code, but can only do so because the other module
had loaded it, so if you removed the 'use' for that module the code
would break. (I just found one of these in my own code while unit
testing...)

OP, Have you read:

perldoc perlmod
perldoc perlmodlib
perldoc perlmodstyle
perldoc -f use
perldoc -f package

And you may want to consider the Learning Perl Objects, References, and
Modules from O'Reilly...

http://danconia.org

[snip]

Advanced Perl Programming covers most of what is in LPORM, but not in as
readable of a fashion. It is also a bit dated, but you can probably get
most of what you need from the perldoc's. If you just like being a
zookeeper (like some of us) then LPORM is worth picking up and the time
to read.

http://danconia.org

I presume that you did the

package My::DB
use DBI;

and that your function is say

sub do_get_db_handle
{
....
$dbh = DBI->connect($data_source, $user, $pass, $driver);
...
$dbh;
}

hence it is called like

use My::DB;
...
my $db = do_get_db_handle(@arglist);
...
$rv = $db->do($statement);

as Will has noted he thinks that the $dbh is a 'blessed' referece,
if you rummage around inside it you will find that yes, it is a
blessed reference. Since your module has already asserted the

'use DBI'

it will have already both 'required' and 'imported' all of
the stuff 'needed' to understand what a blessed reference to
a DBI is all about.

As such your calling script did not need to make the 'use DBI'
since it would be required IN your module. This is a part of
how/why one likes to encapsulate things into perl modules so
that one can hide the common repeatively repeated redundent parts
without having to keep retyping them over and over and over again
in each new script that you need.

HTH.


ciao
drieux

---

Yes, I have 'use DBI', well actually 'use Apache::DBI', in MyModule. So, if I were to try
to create the database handle in my script instead of MyModule, it would fail since my
script knows nothing of the DBI module.

No, but I will.

I will look into it. I've already read Learning Perl and I own Perl Cookbook, Advanced
Perl Programming, and the Perl Pocket Reference, which is very nifty and actually fits in
my pocket! :)

--
Andrew Gaffney
Network Administrator
Skyline Aeronautics, LLC.

That is the gist of my code, yes.

This is what I didn't quite understand. I didn't realize that Perl's "black magic" allowed
the blessed reference to refer back to the object already in memory. In effect, the
blessed reference carries around the entire class object with it.

--
Andrew Gaffney
Network Administrator
Skyline Aeronautics, LLC.

Not quite. The beauty of references is that you don't have to lug the whole object around.
The reference is more like a map that shows where to very quickly find the object. So what
you carry around evcerywhere is access to the object, not the object itself.

Joseph

Thanks for the clarification.

--
Andrew Gaffney
Network Administrator
Skyline Aeronautics, LLC.

It doesn't care. It ignores the path information, but does read any
switches on the line.

Joseph


--
To unsubscribe, e-mail: [Email Removed]
For additional commands, e-mail: [Email Removed]
<http://learn.perl.org/> <http://learn.perl.org/first-response>

well- namely that it works- i honestly don't know /how/ to get perl
to talk telnet *laugh* i guess the proper module would help.

i will investigate this possibility and see what happens :)

off to CPAN.....

ttfn,
willy

You need Net::FTP and/or Net::Telnet.

In my experience it's always better to solve a problem natively
in Perl than to shell out to another application. That way
everything that happens is under your control and the bugs
will be easier to find. I'm certain that, unless there's
a separate reason to use 'expect', you'd be better off
using straight Perl than getting Perl to run ftp (or telnet)
via expect.

Come back if you need any help with the modules.

Rob

expect.nist.gov expect ???

A fine, if under valued, development system.

Off to get the correct 'starter' modules. Try -

http://www.cpan.org/authors/id/S/SN/SNEEX/smtp_Scanner_v3


A small test bed I have been messing with these past few days.

#__Sx___________________________________________________________________
$_=qq|for(ref bless{},chasecreek'systemhouse){s-:+-$"-g&&print$_.$/}|;
while(m|[WC -Sx - Jones @ http://inSecurity.org/]|ig) { print join(" ",
map { defined $_ ? $_ : ""} $`, $&, $', $+), "n";}
__DATA__
('> iudicium ferat
// Have Computer -
v_/_ Will Hack...

|/ ____ |/
"@'/ .. `@"
/_| __/ |_
__U_/

my @ordered_keys = sort { $HofA{$a}[0] cmp $HofA{$b}[1]
||
$a cmp $b } keys %HofA;

I believe that will do it. See if that gets you going.

James

Perl uses its own internal storage method for Hashes.
There is no guarantee of order unless you sort it and
save the results yourself.

You need the key value to get the hash data.
Keys, in of themselves, are of little value.

First, did you catch the later post that pointed out my mistake?
Here's the corrected code:

my @ordered_keys = sort { $HofA{$a}[0] cmp $HofA{$b}[0]
||
$a cmp $b } keys %HofA;

Yes, I only ordered the keys. Sorry if I didn't make that clear.
That's all you need though, right? ;)

foreach (@ordered_keys) {
print "$HofA{$_}[0], $_, $HofA{$_}[1]n";
}

Hope that helps.

James

Hi Jeff.

James was offering you a starting place. The only way to order
a hash is to order its keys, hence 'my @ordered_keys'. What you
do with this sorted list depends on what you want. For instance

foreach (@ordered_keys) {
printf "%s => %sn", $_, $HofA{$_};
}

Also, I wasn't sure whether, by

you meant that the string comparisons for the sort should be
case-insensitive. If so, then your sort should look like

my @ordered_keys = sort {
my ($aa, $bb) = lc $a, lc $b;
$HofA{$aa}[0] cmp $HofA{$bb}[0] or $aa cmp $bb
} keys %HofA;

HTH,

Rob

First, did you catch the later post that pointed out my mistake?
Here's the corrected code:

my @ordered_keys = sort { $HofA{$a}[0] cmp $HofA{$b}[0]
||
$a cmp $b } keys %HofA;

Yes, I only ordered the keys. Sorry if I didn't make that clear.
That's all you need though, right? ;)

foreach (@ordered_keys) {
print "$HofA{$_}[0], $_, $HofA{$_}[1]n";
}

Hope that helps.

James

Research:

Tie::IxHash

Hi Jeff.

I was hoping James would be around, but, briefly:

A hash element is a key/value pair, but it is accessed uniquely
by its key. You can sort the elements on any function of the key,
the value, or both; but the result will be an ordered list of keys.

Does that help? I hope so!

Rob

Are you playing with the code I'm posting? :P

I know how you would like it sorted. I did that. (Actually, I believe
I did miss the case insensitive part, but Rob has already fixed that.)

A Perl hash is an unordered structure. However, if we put the keys in
the order we want and then use those to access the values, we're good
to go. I posted a loop showing this in my last message.

I ordered the keys based on the first value and the key itself, just
like you said. In order to avoid more confusion though, here's a proof
of concept:

#!/usr/bin/perl

use strict;
use warnings;

# create some data
my %HofA = ( orange => ['ZZZ', 'ANDY'],
red => ['AAA', 'AL'],
blue => ['mmm','Betty'],
yellow => ['aaa', 'ZEUS'],
green => ['DDD','Mary Joe'],
violet => ['MMM','Hugo'] );

# sort it
my @ordered_keys = sort { lc($HofA{$a}[0]) cmp lc($HofA{$b}[0])
||
lc($a) cmp lc($b) } keys %HofA;

# print it
foreach (@ordered_keys) {
print "$HofA{$_}[0], $_, $HofA{$_}[1]n";
}

__END__

You'll notice that the above is really just a summary of this thread.
When I run it, I get:

AAA, red, AL
aaa, yellow, ZEUS
DDD, green, Mary Joe
mmm, blue, Betty
MMM, violet, Hugo
ZZZ, orange, ANDY

Which is the output you requested in your original message.

Hope that helps.

James

Are you playing with the code I'm posting? :P

I know how you would like it sorted. I did that. (Actually, I believe
I did miss the case insensitive part, but Rob has already fixed that.)

A Perl hash is an unordered structure. However, if we put the keys in
the order we want and then use those to access the values, we're good
to go. I posted a loop showing this in my last message.

I ordered the keys based on the first value and the key itself, just
like you said. In order to avoid more confusion though, here's a proof
of concept:

#!/usr/bin/perl

use strict;
use warnings;

# create some data
my %HofA = ( orange => ['ZZZ', 'ANDY'],
red => ['AAA', 'AL'],
blue => ['mmm','Betty'],
yellow => ['aaa', 'ZEUS'],
green => ['DDD','Mary Joe'],
violet => ['MMM','Hugo'] );

# sort it
my @ordered_keys = sort { lc($HofA{$a}[0]) cmp lc($HofA{$b}[0])
||
lc($a) cmp lc($b) } keys
%HofA;

# print it
foreach (@ordered_keys) {
print "$HofA{$_}[0], $_, $HofA{$_}[1]n";
}

__END__

You'll notice that the above is really just a summary of this thread.
When I run it, I get:

AAA, red, AL
aaa, yellow, ZEUS
DDD, green, Mary Joe
mmm, blue, Betty
MMM, violet, Hugo
ZZZ, orange, ANDY

Which is the output you requested in your original message.

Hope that helps.

James

No worries. You probably did run my original response, which was
flawed. Mark gave a fix for it shortly after I posted it. Then Rob
pointed out that it was ignoring your case insensitive request today.
All their suggestions are included below.

The Moral: Don't use the original message. Use this one.

Oring sort() conditions is a common Perl idiom. Now you know. ;)

James

Are you saying that 'if-elsif-else' is a compile-time filter? It isn't.
So I guess 'if-elsif-else' runs extraordinarily slow too.

AFAIK Switch allows coding that runs no more slowly than 'if', and lets
you express some solutions much more neatly.

Rob

Far more reliable is: "Don't do what I say, do what I mean." :)

Rob

The problem is that Switch.pm is a source filter, which is effectively
an extra level of processing before compilation.

Personally, I wouldn't use a source filter for anything I cared about.

The docs for Switch state:

There are undoubtedly serious bugs lurking somewhere in code this
funky :-)

and also

Due to the heuristic nature of Switch.pm's source parsing, the
presence of regexes specified with raw "?...?" delimiters may cause
mysterious errors.

--
Paul Johnson - [Email Removed]
http://www.pjcj.net

I haven't spent the time to verify the exact cause, but I think I have
had trouble with the compiler giving me incorrect line numbers for
errors, when I've used Switch. I don't know if it was an isolated
couple of cases or if this a common problem with the module, but it has
turned me off to it.

I am looking forward to the native switch in Perl 6 though.

James

last time i benchmark a source filter, it's about 100 times slower. has that
change since v5.8?

david
--
sub'_{print"@_ ";* = * __ , & }
sub'__{print"@_ ";* = * ___ , & }
sub'___{print"@_ ";* = * ____ , & }
sub'____{print"@_,n"}&{_+Just}(another)->(Perl)->(Hacker)

After all, Perl is a DWIM language. :-)


John
--
use Perl;
program
fulfillment

Hi znur.

Yes, I did suspect my previous answer wouldn't handle the general case, but
I hoped it may be good enough. I'm sure it's not possible using a simple regex.

I've written subroutine split_list() below, which takes a string of characters to
split on and a string to split, a little like the split() built-in. It finds all
the ways to split the string at each of the characters in sequence.

It's a recursive subroutine to make it neater. It works by finding a way to
split on the first character in the list and then calling itself to split
the right-hand half on the remaining characters.

The return value is an array of all the possibilities with the split
characters replaced with hyphens.

Post to the list if you need any help with any part of it.

(Thanks, this was an interesting little problem!)

Cheers,

Rob



use strict;
use warnings;

sub split_list {

my ($list, $string) = @_;

return ($string) unless $list =~ s/(.)//;
my $split = $1;

my @splits;

while ( $string =~ /$split/g ) {

my $pos = pos $string;
my $left = substr $string, 0, $pos - 1;
my $right = substr $string, $pos;

push @splits, map "$left-$_", split_list($list, $right);
}

return @splits;
}

my @ret = split_list ('HKD', 'xHxxHyyKzDt');

print map "$_n", @ret;


**OUTPUT

x-xxHyy-z-t
xHxx-yy-z-t




--
To unsubscribe, e-mail: [Email Removed]
For additional commands, e-mail: [Email Removed]
<http://learn.perl.org/> <http://learn.perl.org/first-response>

That only shows substrings within string that begin with start letter.

Visually -
abracadabra becomes:
abra
abraca
abracada
abracadabra
....aca
....acada
....acadabra
......ada
......adabra
........abra

So, you see what you get as a substring, with 'a' as the starting
letter. Is that what you wanted?

What Rob wrote splits combinations of class set from class group
strings. Two totally different things.

I guess I am confused.
-Sx-

If I understand the problem, what you want to do is vary the greediness
of the match. One way to do that is to generate the regexs. Try this:

#!/usr/bin/perl

use strict;
use warnings;


my $seq = 'xHxxHyyKzDt';

my @pat = ( '(.+)', '(.+?)' );

my %uniq;

for my $a (0..1) {
for my $b (0..1) {
for my $c (0..1) {
for my $d (0..1) {
my $pat = '^' .
$pat[$a] . 'H' .
$pat[$b] . 'K' .
$pat[$c] . 'D' .
$pat[$d] . '$' ;

$uniq{"$1 $2 $3 $4"}++ if $seq =~ /$pat/;
}
}
}
}

print join "n", keys %uniq;

I don't know actually what version supports it?

What version of perl are we talking about here?

5.8 or 6 maybe?

Ok, welcome to the wonderful world of dynamic code generation. The code
below is ugly as sin, but see if it does what you want.

#!/usr/bin/perl

use strict;
use warnings;


my $seq = 'xHxxHyyKzDt';

my @any = ( '(.+)', '(.+?)' );

my @vars = ('a'..'z');
my @keys = qw( H K D );


my $cmd;

my $index = 0;
for my $key (@keys) {
$cmd .= "for my $$vars[$index++] (0..1) {n";
}
$cmd .= "for my $$vars[$index++] (0..1) {n";


$index = 0;
$cmd .= "my $any = '^' .n";
for my $key (@keys) {
$cmd .= "$any[$$vars[$index]] . '$keys[$index++]' .n";
}
$cmd .= "$any[$$vars[$index]] . '$';n";

$cmd .= "$uniq{"";
$index = 0;
for my $i (1..@keys+1) {
$cmd .= "$$i ";
}
chop $cmd; #remove the last space we added
$cmd .= ""}++ if $seq =~ /$any/;n";

$index = 0;
for (0..@keys) {
$cmd .= "}n";
}

#print $cmd;
my %uniq;
eval $cmd;

print join("n", keys(%uniq)) . "n";

The @keys array can hold regexs as well as strings:

my @keys = ('H', qr/K[ED]?/, qr/D{1,2}/);

Regards,
Randy.

THANKS A LOT :)
oznur

Are you just saying that the patterns that you want to split on
can be regexes themselves instead of plain strings? I think my solution will
do that fine, but you need to give us an example. All the solutions
you've been offered so far are based on your original example. You said:

znur tastan wrote:

which has been solved. Can you explain the full problem a little better?

This is a proposal for Perl 6.0. The latest development source is at 5.9
and the latest stable release is 5.8.3.

Rob

I think there has been a discontuinty in replies (the mails didn't contain
everything) and I couldn't be very explanatory
(:( sorry)
you are right the patterns can ve regexes themselves. I just couldn't figure
out how to modify your code.

My problem was this
I have a sets of patterns
and a string
and I know in which order these patterns are supposed to exists
What I want is to extract all the substrings when the patterns match to
the string.

oznur

OK, but may we have an example of a target string and a set of patterns that
you need to work with?

Rob

That is what will be supported in Perl 6 - so unless you have - say -
Perl 5.9 bleeding running in production -- you will prolly have to wait
a few more days? weeks? months? before Perl 6 is considered production.


In the meantime, try this test for development of R/E tests:

perl -w -Mre=debug -e '"abracadabra" =~ m/a.*a/g;'


For example -

perl -w -Mre=debug -e '"abracadabra" =~ m/a.*a/g;'
Freeing REx: `","'
Compiling REx `a.*a'
size 7 Got 60 bytes for offset annotations.
first at 1
1: EXACT <a>(3)
3: STAR(5)
4: REG_ANY(0)
5: EXACT <a>(7)
7: END(0)
anchored `a' at 0 floating `a' at (checking floating)
minlen 2
Offsets: [7]
1[1] 0[0] 3[1] 2[1] 4[1] 0[0] 5[0]
Guessing start of match, REx `a.*a' against `abracadabra'...
Found floating substr `a' at offset 3...
Found anchored substr `a' at offset 0...
Guessed: match at offset 0
Matching REx `a.*a' against `abracadabra'
Setting an EVAL scope, savestack=3
0 <> <abracadabra> | 1: EXACT <a>
1 <a> <bracadabra> | 3: STAR
REG_ANY can match 10 times out of...
Setting an EVAL scope, savestack=3
10 <abracadabr> <a> | 5: EXACT <a>
11 <abracadabra> <> | 7: END
Match successful!
Freeing REx: `"a.*a"'


Or, another example:

perl -w -Mre=debug -e '"abracadabra" =~ /r.*a/;'
Freeing REx: `","'
Compiling REx `r.*a'
size 7 Got 60 bytes for offset annotations.
first at 1
1: EXACT <r>(3)
3: STAR(5)
4: REG_ANY(0)
5: EXACT <a>(7)
7: END(0)
anchored `r' at 0 floating `a' at (checking floating)
minlen 2
Offsets: [7]
1[1] 0[0] 3[1] 2[1] 4[1] 0[0] 5[0]
Guessing start of match, REx `r.*a' against `abracadabra'...
Found floating substr `a' at offset 3...
Found anchored substr `r' at offset 2...
Starting position does not contradict /^/m...
Guessed: match at offset 2
Matching REx `r.*a' against `racadabra'
Setting an EVAL scope, savestack=3
2 <ab> <racadabra> | 1: EXACT <r>
3 <abr> <acadabra> | 3: STAR
REG_ANY can match 8 times out of...
Setting an EVAL scope, savestack=3
10 <abracadabr> <a> | 5: EXACT <a>
11 <abracadabra> <> | 7: END
Match successful!
Freeing REx: `"r.*a"'


Note the line:
REG_ANY can match 10 times out of...


.... it will help you avoid infinity.
HTH/Sx