view release on metacpan or  search on metacpan

t/lib/Capture/Tiny.pm  view on Meta::CPAN

  # setup pipes
  $stash->{$_}{$which} = IO::Handle->new for qw/tee reader/;
  pipe $stash->{reader}{$which}, $stash->{tee}{$which};
  # _debug( "# pipe for $which\: " .  _name($stash->{tee}{$which}) . " " . fileno( $stash->{tee}{$which} ) . " => " . _name($stash->{reader}{$which}) . " " . fileno( $stash->{reader}{$which}) . "\n" );
  select((select($stash->{tee}{$which}), $|=1)[0]); # autoflush
  # setup desired redirection for parent and child
  $stash->{new}{$which} = $stash->{tee}{$which};
  $stash->{child}{$which} = {
    stdin   => $stash->{reader}{$which},
    stdout  => $stash->{old}{$which},
    stderr  => $stash->{capture}{$which},

t/lib/Capture/Tiny.pm  view on Meta::CPAN

    _start_tee( $_ => $stash ) if $do_tee; # tees may change $stash->{new}
  }
  _wait_for_tees( $stash ) if $do_tee;
  # finalize redirection
  $stash->{new}{stderr} = $stash->{new}{stdout} if $do_merge;
  # _debug( "# redirecting in parent ...\n" );
  _open_std( $stash->{new} );
  # execute user provided code
  my ($exit_code, $inner_error, $outer_error, @result);
  {
    local *STDIN = *CT_ORIG_STDIN if $localize{stdin}; # get original, not proxy STDIN

 view release on metacpan or  search on metacpan

Tools.pm  view on Meta::CPAN

B<Output:> Nothing (for the time being). C<die()>s (C<croak($!)> really) if something goes wrong.

=cut

#todo: use openstr() as in readfile(), transparently gzip .gz filenames and so on
sub writefile {
    my($filename,$text)=@_;
    if(ref($filename) eq 'ARRAY'){
	writefile(@$_) for @$filename;
	return;

Tools.pm  view on Meta::CPAN

=head2 makedir

Input: One or two arguments.

Works like perls C<mkdir()> except that C<makedir()> will create nesessary parent directories if they dont exists.

First input argument: A directory name (absolute, starting with C< / > or relative).

Second input argument: (optional) permission bits. Using the normal C<< 0777^umask() >> as the default if no second input argument is provided.

 view release on metacpan or  search on metacpan

lib/Acme/URL.pm  view on Meta::CPAN

    my $line = $self->get_linestr;   # get me current line of code
    my $pos  = $self->offset;        # position just after "http"
    my $url  = substr $line, $pos;   # url & everything after "http"

    for my $c (split //, $url) {
        # if blank, semicolon, closing parenthesis or a comma(!) then no longer a URL
        last if $c eq q{ };
        last if $c eq q{;};
        last if $c eq q{)};
        last if $c eq q{,};
        $pos++;

 view release on metacpan or  search on metacpan

lib/Acme/VOYAGEGROUP/ConferenceRoom.pm  view on Meta::CPAN

use strict;
use warnings;
use Carp;
use utf8;
use UNIVERSAL::require;
use parent 'Exporter';

binmode STDOUT, ":utf8";
binmode STDERR, ":utf8";

our $VERSION = "0.01";

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

    my $sym = "$caller\::AUTOLOAD";

    $sym->{$cwd} = sub {
        my $pwd = Cwd::cwd();
        if (my $code = $sym->{$pwd}) {
            goto &$code unless $cwd eq $pwd; # delegate back to parent dirs
        }
        $$sym =~ /([^:]+)$/ or die "Cannot autoload $caller";
        unshift @_, ($self, $1);
        goto &{$self->can('call')} unless uc($1) eq $1;
    };

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

	my $cwd  = Cwd::cwd();
	my $sym  = "${who}::AUTOLOAD";
	$sym->{$cwd} = sub {
		my $pwd = Cwd::cwd();
		if ( my $code = $sym->{$pwd} ) {
			# Delegate back to parent dirs
			goto &$code unless $cwd eq $pwd;
		}
		unless ($$sym =~ s/([^:]+)$//) {
			# XXX: it looks like we can't retrieve the missing function
			# via $$sym (usually $main::AUTOLOAD) in this case.

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

 [ Documentation ]
 - Somewhat simplify bundled example.

 [ Other ]
 - Updated: Use Sub::Util instead of Sub::Name.
 - Updated: Use base.pm instead of parent.pm.

0.003	2014-09-11

 [ Packaging ]
 - Switch to Dist::Inkt.

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

	my $cwd  = Cwd::cwd();
	my $sym  = "${who}::AUTOLOAD";
	$sym->{$cwd} = sub {
		my $pwd = Cwd::cwd();
		if ( my $code = $sym->{$pwd} ) {
			# Delegate back to parent dirs
			goto &$code unless $cwd eq $pwd;
		}
		unless ($$sym =~ s/([^:]+)$//) {
			# XXX: it looks like we can't retrieve the missing function
			# via $$sym (usually $main::AUTOLOAD) in this case.

 view release on metacpan or  search on metacpan

lib/Acme/YAPC/Okinawa/ppport.h  view on Meta::CPAN

op_integerize|||
op_linklist||5.013006|
op_lvalue_flags|||
op_lvalue||5.013007|
op_null||5.007002|
op_parent||5.021002|n
op_prepend_elem||5.013006|
op_refcnt_dec|||
op_refcnt_inc|||
op_refcnt_lock||5.009002|
op_refcnt_unlock||5.009002|

 view release on metacpan or  search on metacpan

lib/Acme/constant.pm  view on Meta::CPAN

    use Acme::constant TIMESTAMP => scalar localtime;

Constants return lists, not arrays (you don't use C<@> syntax, do
you?), so in order to get single element, you will need to put a
constant in parenthesis.

    use Acme::constant NUMBERS => 1..6;
    print join(" ", (NUMBERS)[2..4]), "\n";

=head2 Assignments

lib/Acme/constant.pm  view on Meta::CPAN

    use Acme::constant SOMETHING => 0;
    SOMETHING = (1, 2); # WRONG!
    print "Something is ", join(", ", SOMETHING), ".\n";

In order to force list interpretation, you need to put constant in
the parenthesis.

    use Acme::constant SOMETHING => 0;
    (SOMETHING) = (1, 2);
    print "Something is ", join(", ", SOMETHING), ".\n";

lib/Acme/constant.pm  view on Meta::CPAN

    use Acme::constant SOMETHING => (1, 2);
    SOMETHING = 3; # WRONG!
    print "Something is ", SOMETHING, ".\n";

To fix that, you need to put constant in parenthesis. This is only
needed when constant has different number of elements than one, so
after such assignment, you can use normal assignment, without
parenthesis.

    use Acme::constant SOMETHING => (1, 2);
    (SOMETHING) = 3;
    print "Something is ", SOMETHING, ".\n";
    SOMETHING = 4;

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

    my $cwd  = Cwd::cwd();
    my $sym  = "${who}::AUTOLOAD";
    $sym->{$cwd} = sub {
        my $pwd = Cwd::cwd();
        if ( my $code = $sym->{$pwd} ) {
            # delegate back to parent dirs
            goto &$code unless $cwd eq $pwd;
        }
        $$sym =~ /([^:]+)$/ or die "Cannot autoload $who - $sym";
        unshift @_, ($self, $1);
        goto &{$self->can('call')} unless uc($1) eq $1;

 view release on metacpan or  search on metacpan

lib/Acme/ful.pm  view on Meta::CPAN

use strict;
use warnings;

package Acme::ful;

use parent 'ful';

our $VERSION = '0.11';

1;

 view release on metacpan or  search on metacpan

eg/acrux_std.pl  view on Meta::CPAN

# perl -Ilib eg/acrux_std.pl error
# perl -Ilib eg/acrux_std.pl noop

package MyApp;

use parent 'Acme::Crux';

use Acrux::Util qw/dumper color/;

our $VERSION = '1.00';

 view release on metacpan or  search on metacpan

share/conf/default-project.yml  view on Meta::CPAN

#
#   Locations for source code and target deployment directories for sync
#

#
# This is where the sync'd code comes from. This is the parent to your
# perl "lib" directory.
#
project_codebase : ${HOME}/src/${project_name}

#

 view release on metacpan or  search on metacpan

lib/ActiveRecord/Simple.pm  view on Meta::CPAN

=head1 SYNOPSIS

    package Model;

    use parent 'ActiveRecord::Simple';

    # connect to the database:
    __PACKAGE__->connect($dsn, $opts);


    package Customer;

    use parent 'Model';

    __PACKAGE__->table_name('customer');
    __PACKAGE__->columns(qw/id first_name last_login/);
    __PACKAGE__->primary_key('id');

    __PACKAGE__->has_many(purchases => 'Purchase');


    package Purchase;

    use parent 'Model';

    __PACKAGE__->auto_load(); ### load table_name, columns and primary key from the database automatically

    __PACKAGE__->belongs_to(customer => 'Customer');

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

	my $cwd  = Cwd::cwd();
	my $sym  = "${who}::AUTOLOAD";
	$sym->{$cwd} = sub {
		my $pwd = Cwd::cwd();
		if ( my $code = $sym->{$pwd} ) {
			# Delegate back to parent dirs
			goto &$code unless $cwd eq $pwd;
		}
		$$sym =~ /([^:]+)$/ or die "Cannot autoload $who - $sym";
		my $method = $1;
		if ( uc($method) eq $method ) {

 view release on metacpan or  search on metacpan

lib/Adapter/Async/Bus.pm  view on Meta::CPAN

package Adapter::Async::Bus;
$Adapter::Async::Bus::VERSION = '0.019';
use strict;
use warnings;

use parent qw(Mixin::Event::Dispatch);
use constant EVENT_DISPATCH_ON_FALLBACK => 0;

=head1 NAME

Adapter::Async::Bus - 

 view release on metacpan or  search on metacpan

lib/Address/PostCode/Australia/Params.pm  view on Meta::CPAN

=cut

use 5.006;
use strict; use warnings;
use Data::Dumper;
use parent 'Exporter';

our @EXPORT_OK = qw(validate);

sub check_num {
    my ($num) = @_;

 view release on metacpan or  search on metacpan

lib/Ado/Build.pm  view on Meta::CPAN

use File::Spec::Functions qw(catdir catfile);
use File::Path qw(make_path);
use File::Copy qw(copy);
use ExtUtils::Installed;
use ExtUtils::Install;
use parent 'Module::Build';
use Exporter qw( import );    #export functionality to Ado::BuildPlugin etc..
our @EXPORT_OK = qw(
  create_build_script process_etc_files do_create_readme
  process_public_files process_templates_files
  ACTION_perltidy ACTION_submit PERL_DIRS);

 view release on metacpan or  search on metacpan

Config.pm  view on Meta::CPAN

   eval {
      $begin_special_vars{PPID} = getppid ();
   };
   if ( $@ ) {
      DBUG_PRINT ("INFO", "Cheating to get the PPID.  It may be wrong!");
      # We can't easily get the parent process id for Windows.
      # So we're going to cheat a bit.  We'll ask if any parent
      # or grandparent process used this module before and call it
      # the parent process!
      $secret_tag = "_ADVANCED_CONFIG_PPID_";

      if ( $ENV{$secret_tag} ) {
         $begin_special_vars{PPID} = $ENV{$secret_tag};
      } else {

Config.pm  view on Meta::CPAN

   # Assume not allowing utf8/Unicode/Wide Char dates ...
   # Or inside the config file itself.
   $control{ALLOW_UTF8} = 0;

   # Controls the behaviour of this module.
   # Only exists in the parent object.
   $self->{CONTROL} = \%control;

   my $key = $self->{SECTION_NAME} = DEFAULT_SECTION;

   my %sections;

Config.pm  view on Meta::CPAN

# In most cases 'create_section' should be called instead!
sub new_section
{
   DBUG_ENTER_FUNC ( @_ );
   my $prototype = shift;;
   my $parent    = shift;
   my $section   = shift;

   my $class = ref ( $prototype ) || $prototype;
   my $self  = {};

   # Create an empty object ...
   bless ( $self, $class );

   if ( ref ( $parent ) ne __PACKAGE__ ) {
      die ("You must provide an ", __PACKAGE__, " object as an argument!\n");
   }

   # Make sure it's really the parent object  ...
   $parent = $parent->{PARENT} || $parent;

   # Trim so we can check if unique ...
   if ( $section ) {
      $section =~ s/^\s+//;   $section =~ s/\s+$//;
      $section = lc ($section);

Config.pm  view on Meta::CPAN

   unless ( $section ) {
      die ("You must provide a section name to use this constructor.\n");
   }

   # Creating a new section for the parent object ...
   if ( exists $parent->{SECTIONS}->{$section} ) {
      die ("Section \"${section}\" already exists!\n");
   }

   # Links the parent & child objects together ...
   $parent->{SECTIONS}->{$section} = $self;
   $self->{SECTION_NAME} = $section;
   $self->{PARENT} = $parent;

   # Holds all the tag data for this section in the config file.
   my %data;
   $self->{DATA} = \%data;

Config.pm  view on Meta::CPAN

{
   DBUG_ENTER_FUNC (@_);
   my $self = shift;
   my $file = shift;

   # Get the main/parent section to work against!
   $self = $self->{PARENT} || $self;

   DBUG_RETURN ( exists $self->{CONTROL}->{RECURSION}->{$file} ? 1 : 0 );
}

Config.pm  view on Meta::CPAN

{
   my $self = shift;
   my $tag  = shift;
   my $opts = shift;

   # Get the main/parent section to work against!
   my $pcfg = $self->{PARENT} || $self;

   # Determine what the "get" options must be ...
   my $get_opts = $pcfg->{CONTROL}->{get_opts};
   $get_opts = get_get_opts ( $opts, $get_opts )  if ( $opts );

Config.pm  view on Meta::CPAN

These methods allow you to access the data loaded into this object.

They all look in the current section for the B<tag> and if the B<tag> couldn't
be found in this section and the I<inherit> option was also set, it will then
look in the parent/main section for the B<tag>.  But if the I<inherit> option
wasn't set it wouldn't look there.

If the requested B<tag> couldn't be found, they return B<undef>.  But if the
I<required> option was used, it may call B<die> instead!

Config.pm  view on Meta::CPAN

   my $file            = shift || "";    # The file the tag was defined in.
   my $force_sensitive = shift || 0;
   my $still_encrypted = shift || 0;
   my $has_variables   = shift || 0;

   # Get the main/parent section to work against!
   # my $pcfg = $self->get_section();
   my $pcfg = $self->{PARENT} || $self;

   # Check if case insensitive handling was requested ...
   $tag = lc ($tag)  if ( $pcfg->{CONTROL}->{read_opts}->{tag_case} );

Config.pm  view on Meta::CPAN

   if ( $new_tag =~ m/^shft3+$/i ) {
      warn ("You may not use \"${new_tag}\" as your new tag name!\n");
      return DBUG_RETURN (0);
   }

   # Get the main/parent section to work against!
   my $pcfg = $self->{PARENT} || $self;

   # Check if a case insensitive lookup was requested ...
   if ( $pcfg->{CONTROL}->{read_opts}->{tag_case} ) {
      $old_tag = lc ($old_tag)  if ( $old_tag );

Config.pm  view on Meta::CPAN

   if ( $new_tag =~ m/^shft3+$/i ) {
      warn ("You may not use \"${new_tag}\" as your new tag name!\n");
      return DBUG_RETURN (0);
   }

   # Get the main/parent section to work against!
   my $pcfg = $self->{PARENT} || $self;

   # Check if a case insensitive lookup was requested ...
   $tag = lc ($tag)  if ( $pcfg->{CONTROL}->{read_opts}->{tag_case} && $tag );

Config.pm  view on Meta::CPAN

   unless ( defined $tag ) {
      return DBUG_RETURN (0);   # Nothing to delete!
   }

   # Get the main/parent section to work against!
   my $pcfg = $self->{PARENT} || $self;

   # Check if a case insensitive lookup was requested ...
   $tag = lc ($tag)  if ( $pcfg->{CONTROL}->{read_opts}->{tag_case} && $tag );

Config.pm  view on Meta::CPAN

   DBUG_ENTER_FUNC ( @_ );
   my $self     = shift;
   my $section  = shift;
   my $required = shift || 0;

   $self = $self->{PARENT} || $self;     # Force to parent section ...

   unless ( defined $section ) {
      $section = DEFAULT_SECTION;
   } elsif ( $section =~ m/^\s*$/ ) {
      $section = DEFAULT_SECTION;

Config.pm  view on Meta::CPAN

Creates a new section called I<$name> within the current Advanced::Config object
I<$cfg>.  It returns the I<Advanced::Config> object that it created.  If a
section of that same name already exists it will return B<undef>.

There is no such thing as sub-sections, so if I<$cfg> is already points to a
section, then it looks up the parent object and associates the new section with
the parent object instead.

=cut

sub create_section
{

Config.pm  view on Meta::CPAN

      } elsif ( $tag =~ m/${pattern}/i ) {
         push (@lst, $tag);
      }
   }

   # Are we searching the parent/main section as well?
   if ( $inherit && $pcfg != $self ) {
      DBUG_PRINT ("INFO", "Also searching the 'main' section ...");
      foreach my $tg ( sort keys %{$pcfg->{DATA}} ) {
         # Ignore tags repeated from the current section
         next  if ( exists $self->{DATA}->{$tg} );

Config.pm  view on Meta::CPAN

            push (@lst, $tag);
         }
      }
   }

   # Are we searching the parent/main section as well?
   if ( $inherit && $pcfg != $self ) {
      DBUG_PRINT ("INFO", "Also searching the main section ...");
      foreach my $tg ( sort keys %{$pcfg->{DATA}} ) {
         # Ignore tags repeated from the current section
         next  if ( exists $self->{DATA}->{$tg} );

Config.pm  view on Meta::CPAN

{
   DBUG_ENTER_FUNC (@_);
   my $self    = shift;
   my $pattern = shift;

   $self = $self->{PARENT} || $self;     # Force to parent section ...

   my @lst;
   foreach my $name ( sort keys %{$self->{SECTIONS}} ) {
      unless ( $pattern ) {
         push (@lst, $name);

Config.pm  view on Meta::CPAN

sub filename
{
   DBUG_ENTER_FUNC ( @_ );
   my $self = shift;

   # The request only applies to the parent instance ...
   $self = $self->{PARENT} || $self;

   DBUG_RETURN( $self->{CONTROL}->{filename} );
}

Config.pm  view on Meta::CPAN

sub get_cfg_settings
{
   DBUG_ENTER_FUNC (@_);
   my $self = shift;

   # Get the main/parent section to work against!
   my $pcfg = $self->{PARENT} || $self;

   my $ctrl = $pcfg->{CONTROL};

   my (%r_opts, %g_opts, %d_opts);

Config.pm  view on Meta::CPAN

   } else {
      # 1. Look in the current section ...
      ( $val, $mask_flag, $file, $encrypt_flag ) = $self->_base_get2 ( $var );

      # 2. Look in the parent section ... (if not already there)
      if ( ! defined $val && $self != $pcfg ) {
         ( $val, $mask_flag, $file, $encrypt_flag ) = $pcfg->_base_get2 ( $var );
      }

      # 3. Look in the requested section(s) ...

Config.pm  view on Meta::CPAN

   # Start of real work ...
   # -------------------------------------------------------------

   my ($pcfg, $cmt, $la, $ra, $asgn) = (undef, '#', '${', '}', '=');
   if ( $is_obj ) {
      # Get the main/parent section to work against!
      $pcfg = $self->{PARENT} || $self;

      # Look in the Read Options hash for current settings ...
      $cmt  = $pcfg->{CONTROL}->{read_opts}->{comment};
      $la   = $pcfg->{CONTROL}->{read_opts}->{variable_left};

 view release on metacpan or  search on metacpan

builder/Affix.pm  view on Meta::CPAN

                my $pre = Path::Tiny->cwd->child( qw[blib arch auto], $opt{meta}->name )->absolute;

                #$pre->mkpath;
                for my $sub (qw[lib include]) {
                    for my $kid ( $ret->child($sub)->children ) {
                        $pre->child( $sub, $kid->basename )->parent->mkpath;
                        $kid->copy( $pre->child( $sub, $kid->basename ) );
                    }
                }
            }
            else {

builder/Affix.pm  view on Meta::CPAN

        next if $destfile->is_dir;
        next
            if $destfile->is_file &&
            stat( $destfile->absolute->stringify )->mtime < $header->{Time};
        warn $destfile;
        $destfile->parent->mkpath;
        my $raw = '';
        while ( ( $status = $u->read( my $buff ) ) > 0 ) { $raw .= $buff }
        $destfile->spew_raw($raw);
        $destfile->touch;
        $retval = $destfile->parent if $destfile =~ 'build.log';
    }
    return $retval;
}
1;

 view release on metacpan or  search on metacpan

lib/Agent/TCLI/Control.pm  view on Meta::CPAN

		'Control'."::".$cmd->name;

	if ( defined( $registered_commands[$$self]{'registered'}{ $package }) )
	{
		# We could die here, but then one would have to iterate over each failure
		# Though it might be nice to make failure more apparent. A MOTD perhaps?
		$self->Verbose( "RegisterCommand: ".$cmd->name." already registered! ",0 );
		$self->Verbose( "RegisterCommand: registered_commands dump  ",1,$self->registered_commands );
	}
	else
	{

 view release on metacpan or  search on metacpan

examples/keepalive.pl  view on Meta::CPAN

$addr = $tcp->address();
print "Got tcp address $addr.\n";

unless ($pid=fork()) {
	# child
	print "forked. parent is $$.\n";
	my $serv;
	sleep 1;	# give time for server to setup...
        my $con = new IO::Socket::INET(
                Proto => 'tcp',
                Timeout => 10,

examples/keepalive.pl  view on Meta::CPAN

	print "C: made it! ", ref( $con ), "\n";
	print $con "Hello There!\n";
	print "C: ", <$con>, "finished printing, exiting.\n";;
	exit 0;
}
# parent

print "forked.  child is $pid.\n";
print "S: waiting for incoming...\n";
my $client = $tcp->accept() or die "ACK!";

 view release on metacpan or  search on metacpan

lib/Aion/Format.pm  view on Meta::CPAN

=item 5. All variables in C<{{: var }}> are replaced with C<[^\n]*>. Those. must be on the same line. 

=item 6. Expressions in double square brackets (C<[[ ... ]]>) may not exist. 

=item 7. Double parentheses (C<(( ... ))>) are used as parentheses. 5. C<||> - or.

=back

	my $re = nous [
	q{

 view release on metacpan or  search on metacpan

lib/Aion.pm  view on Meta::CPAN

	ExIs->new(ro => 10)->rw(30)->rw  # -> 30

The function with C<*> does not hold the meaning:

	package Node { use Aion;
	    has parent => (is => "rw*", isa => Maybe[Object["Node"]]);
	}
	
	my $root = Node->new;
	my $node = Node->new(parent => $root);
	
	$node->parent->parent   # -> undef
	undef $root;
	$node->parent   # -> undef
	
	# And by setter:
	$node->parent($root = Node->new);
	
	$node->parent->parent   # -> undef
	undef $root;
	$node->parent   # -> undef

=head2 isa => $type

Indicates the type, or rather - a validator, feature.

 view release on metacpan or  search on metacpan

t/_parse_xml.t  view on Meta::CPAN

<?xml-stylesheet type="text/xsl" href="/interface/templates/finance.xsl?C3-D4"?>
<main responseType="accepted" crc="40252555">
  <billing income-monthly="0" expense-monthly="484" balance-begin="1936" balance-end="1452" last-day="06.05.2014" request-date="06.05.2014">
    <income id="383554863" amount="0" type="1" comment="Датой платежа считается дата зачисления средств на Ваш лицевой счет в АКАДО." description="Поступления на счет в...
    <expense id="383554875" amount="484" type="2" description="Стоимость услуг в мае 2014">
      <bill id="383554876" parent="383554875" amount="4" description="Аренда кабельного модема"/>
      <bill id="383554877" parent="383554875" amount="480" description="Услуги интернет">
        <bill id="383554878" parent="383554877" amount="390" description="АКАДО Интернет 15 (Абонентская плата - av12345)"/>
        <bill id="383554879" parent="383554877" amount="90" description="АКАДО Интернет 15 (Поддержка внешнего IP-адреса - av12345)"/>
      </bill>
    </expense>
    <bill id="383554877" parent="383554875" amount="480" description="Услуги интернет">
      <bill id="383554878" parent="383554877" amount="390" description="АКАДО Интернет 15 (Абонентская плата - av12345)"/>
      <bill id="383554879" parent="383554877" amount="90" description="АКАДО Интернет 15 (Поддержка внешнего IP-адреса - av12345)"/>
    </bill>
    <bill id="383554886" amount="0" type="5" comment="Рекомендуемая сумма оплаты не включает доплату за услуги в текущем месяце." description="Рекомендуемая сумма для...
      <bill id="383554887" parent="383554886" amount="1452" description="Остаток на счете на 31.05.2014"/>
      <bill id="383554888" parent="383554886" amount="484" description="Стоимость услуг в следующем календарном месяце">
        <bill id="383554889" parent="383554888" amount="480" description="УСЛУГИ ИНТЕРНЕТ"/>
        <bill id="383554890" parent="383554888" amount="4" description="Аренда кабельного модема"/>
      </bill>
    </bill>
    <bill id="383554888" parent="383554886" amount="484" description="Стоимость услуг в следующем календарном месяце">
      <bill id="383554889" parent="383554888" amount="480" description="УСЛУГИ ИНТЕРНЕТ"/>
      <bill id="383554890" parent="383554888" amount="4" description="Аренда кабельного модема"/>
    </bill>
    <prepay/>
  </billing>
</main>

 view release on metacpan or  search on metacpan

lib/Akamai/Edgegrid.pm  view on Meta::CPAN

=item $ua = Akamai::Edgegrid->new( %options )

This method constructs a new C<Akamai::EdgeGrid> object and returns it.  This
is a subclass of C<LWP::UserAgent> and accepts all Key/value pair arguments
accepted by the parent class.  In addition The following required key/value
pairs must be provided:

    KEY           SOURCE
    ------------- -----------------------------------------------
    client_token  from "Credentials" section of Manage APIs UI

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

opmethod_stash|5.021007||Viu
OpMORESIB_set|5.021011|5.003007|p
OP_NAME|5.007003|5.007003|
op_null|5.007002|5.007002|
OPpALLOW_FAKE|5.015006||Viu
op_parent|5.025001|5.025001|n
OPpARG1_MASK|5.021004||Viu
OPpARG2_MASK|5.021004||Viu
OPpARG3_MASK|5.021004||Viu
OPpARG4_MASK|5.021004||Viu
OPpARGELEM_AV|5.025004||Viu

ppport.h  view on Meta::CPAN

#ifndef OpMORESIB_set
#  define OpMORESIB_set(o, sib)          ((o)->op_sibling = (sib))
#endif

#ifndef OpLASTSIB_set
#  define OpLASTSIB_set(o, parent)       ((o)->op_sibling = NULL)
#endif

#ifndef OpMAYBESIB_set
#  define OpMAYBESIB_set(o, sib, parent) ((o)->op_sibling = (sib))
#endif

#ifndef HEf_SVKEY
#  define HEf_SVKEY                      -2
#endif

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

    my $sym = "$caller\::AUTOLOAD";

    $sym->{$cwd} = sub {
        my $pwd = Cwd::cwd();
        if (my $code = $sym->{$pwd}) {
            goto &$code unless $cwd eq $pwd; # delegate back to parent dirs
        }
        $$sym =~ /([^:]+)$/ or die "Cannot autoload $caller";
        unshift @_, ($self, $1);
        goto &{$self->can('call')} unless uc($1) eq $1;
    };

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

	my $cwd  = Cwd::cwd();
	my $sym  = "${who}::AUTOLOAD";
	$sym->{$cwd} = sub {
		my $pwd = Cwd::cwd();
		if ( my $code = $sym->{$pwd} ) {
			# Delegate back to parent dirs
			goto &$code unless $cwd eq $pwd;
		}
		unless ($$sym =~ s/([^:]+)$//) {
			# XXX: it looks like we can't retrieve the missing function
			# via $$sym (usually $main::AUTOLOAD) in this case.