use strict;
use warnings;

my @methodcalls = qw (getExeName getTempName);
my @getDataMethods = qw (getNameType);

my $obj = Foo->new();

my %hash;
my $counter=0;
for my $call (@methodcalls)
{
        $hash{"temp".$counter} = $obj->$call;
        $counter++;
}

for my $call (@getDataMethods)
{
        $hash{"temp".$counter} = $obj->getData->$call;
        $counter++;
}

for (keys %hash)
{
        print "$_\t $hash{$_}\n";
}


package Foo;

sub new
{
        return bless \{}, shift;
}

sub getExeName
{
        return "exename";
}

sub getTempName
{
        return "tempname";
}

sub getData
{
        return shift;
}

sub getNameType
{
        return "nametype";
}
[download]

Note that the getData->getNameType call has to be treated separately from the simple method calls. If you have other (possibly more complex) chained methods, you'll have to adapt the code to handle those as well (unless someone can think of a better way?)

Update: As BrowserUK has said, the chained methods can be done with a string eval. It's a slow and ugly way of doing it, but it works:

use strict;
use warnings;

my $obj = Foo->new();

my %hash;
my $counter=0;
my @methodcalls = qw (getExeName getTempName getData->getNameType);

for my $call (@methodcalls)
{
        my $evalstring = "\$obj->$call";
        $hash{"temp".$counter} = eval($evalstring);
        $counter++;
}

for (keys %hash)
{
        print "$_\t $hash{$_}\n";
}
[download]

It mostly depends on how you get the data from the API. Its quite likely that a foreach loop (or a while loop) will get the job done, but not easy to say without knowing exactly how you are getting the data in the first place!

hi doward, i will try to be more clear .

my %replacehash;

$replacehash{TEMP1} = $flow->getExeName();
$replacehash{TEMP2} = $flow->getTempName();
$replacehash{TEMP3} = $flow->getData()->getNameType();
....
[download]

All the API's are different .

You can do the first two quite easily

@replacehash{ map{ "TEMP$_" } 1 .. 2 } = 
    map{ $flow->$_ } qw[getExeName getTempName];
[download]

Doing the third one, with the double level of indirection, would probably require a string eval.

Whether you should do this is another matter entirely. It would have to be a pretty long list to warrent it, and even then you would probably be better having the $flow class provide an API that returned the hash. That way the construction need only be done once and the user of the $flow object can just do

my %replacehash = $flow->getAll();
[download]

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

Lingua non convalesco, consenesco et abolesco. -- Rule 1 has a caveat! -- Who broke the cabal?

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

You could try

my %replacehash = (
        TEMP1 => $flow->getExeName(),
        TEMP2 => $flow->getTempName(),
        TEMP3 => $flow->getData()->getNameType(),
)
[download]

(If you call a method with no arguments, like here, you could also omit the empty pair of parentheses, but that's not the point here.)

Also

my %replacehash;
@replacehash{map { "TEMP$_" } 1 .. 3} = (
        $flow->getExeName(),
        $flow->getTempName(),
        $flow->getData()->getNameType(),
)
[download]

my %replacementhash = map { $_="TEMP$_"; $_ => "contains $_"} 1..4;
[download]

Seriously, it all really depends, on how you actually get the values, i.e. on your APIs. Probably a for or a while loop are the best way to go. Hard to tell anyway, without seeing real code...

Cheers,
Matt