javonet-ruby-sdk 2.4.10 → 2.4.11

data/lib/javonet-ruby-sdk/Binaries/Perl/MacOs/X64/deps/lib/perl5/darwin-thread-multi-2level/Moose/Manual/MOP.pod

@@ -1,214 +0,0 @@
-# PODNAME: Moose::Manual::MOP
-# ABSTRACT: The Moose (and Class::MOP) meta API
-
-__END__
-
-=pod
-
-=encoding UTF-8
-
-=head1 NAME
-
-Moose::Manual::MOP - The Moose (and Class::MOP) meta API
-
-=head1 VERSION
-
-version 2.2207
-
-=head1 INTRODUCTION
-
-Moose provides a powerful introspection API built on top of
-C<Class::MOP>. "MOP" stands for Meta-Object Protocol. In plainer
-English, a MOP is an API for performing introspection on classes,
-attributes, methods, and so on.
-
-In fact, it is C<Class::MOP> that provides many of Moose's core
-features, including attributes, before/after/around method modifiers,
-and immutability. In most cases, Moose takes an existing C<Class::MOP>
-class and subclasses it to add additional features. Moose also adds
-some entirely new features of its own, such as roles, the augment
-modifier, and types.
-
-If you're interested in the MOP, it's important to know about
-C<Class::MOP> so you know what docs to read. Often, the introspection
-method that you're looking for is defined in a C<Class::MOP> class,
-rather than Moose itself.
-
-The MOP provides more than just I<read-only> introspection. It also
-lets you add attributes and methods, apply roles, and much more. In
-fact, all of the declarative Moose sugar is simply a thin layer on top
-of the MOP API.
-
-If you want to write Moose extensions, you'll need to learn some of
-the MOP API. The introspection methods are also handy if you want to
-generate docs or inheritance graphs, or do some other runtime
-reflection.
-
-This document is not a complete reference for the meta API. We're just
-going to cover some of the highlights, and give you a sense of how it
-all works. To really understand it, you'll have to read a lot of other
-docs, and possibly even dig into the Moose guts a bit.
-
-=head1 GETTING STARTED
-
-The usual entry point to the meta API is through a class's metaclass
-object, which is a L<Moose::Meta::Class>. This is available by calling
-the C<meta> method on a class or object:
-
-  package User;
-
-  use Moose;
-
-  my $meta = __PACKAGE__->meta;
-
-The C<meta> method is added to a class when it uses Moose.
-
-You can also use C<< Class::MOP::Class->initialize($name) >> to get a
-metaclass object for any class. This is safer than calling C<<
-$class->meta >> when you're not sure that the class has a meta method.
-
-The C<< Class::MOP::Class->initialize >> constructor will return an
-existing metaclass if one has already been created (via Moose or some
-other means). If it hasn't, it will return a new C<Class::MOP::Class>
-object. This will work for classes that use Moose, meta API classes,
-and classes which don't use Moose at all.
-
-=head1 USING THE METACLASS OBJECT
-
-The metaclass object can tell you about a class's attributes, methods,
-roles, parents, and more. For example, to look at all of the class's
-attributes:
-
-  for my $attr ( $meta->get_all_attributes ) {
-      print $attr->name, "\n";
-  }
-
-The C<get_all_attributes> method is documented in
-C<Class::MOP::Class>. For Moose-using classes, it returns a list of
-L<Moose::Meta::Attribute> objects for attributes defined in the class
-and its parents.
-
-You can also get a list of methods:
-
-  for my $method ( $meta->get_all_methods ) {
-      print $method->fully_qualified_name, "\n";
-  }
-
-Now we're looping over a list of L<Moose::Meta::Method> objects. Note
-that some of these objects may actually be a subclass of
-L<Moose::Meta::Method>, as Moose uses different classes to represent
-wrapped methods, delegation methods, constructors, etc.
-
-We can look at a class's parent classes and subclasses:
-
-  for my $class ( $meta->linearized_isa ) {
-      print "$class\n";
-  }
-
-  for my $subclass ( $meta->subclasses ) {
-      print "$subclass\n";
-  }
-
-Note that both these methods return class I<names>, not metaclass
-objects.
-
-=head1 ALTERING CLASSES WITH THE MOP
-
-The metaclass object can change the class directly, by adding
-attributes, methods, etc.
-
-As an example, we can add a method to a class:
-
-  $meta->add_method( 'say' => sub { print @_, "\n" } );
-
-Or an attribute:
-
-  $meta->add_attribute( 'size' => ( is => 'rw', isa  => 'Int' ) );
-
-Obviously, this is much more cumbersome than using Perl syntax or
-Moose sugar for defining methods and attributes, but this API allows
-for very powerful extensions.
-
-You might remember that we've talked about making classes immutable
-elsewhere in the manual. This is a good practice. However, once a
-class is immutable, calling any of these update methods will throw an
-exception.
-
-You can make a class mutable again simply by calling C<<
-$meta->make_mutable >>. Once you're done changing it, you can
-restore immutability by calling C<< $meta->make_immutable >>.
-
-However, the most common use for this part of the meta API is as
-part of Moose extensions. These extensions should assume that they are
-being run before you make a class immutable.
-
-=head1 GOING FURTHER
-
-If you're interested in extending Moose, we recommend reading all of
-the "Meta" and "Extending" recipes in the L<Moose::Cookbook>. Those
-recipes show various practical applications of the MOP.
-
-If you'd like to write your own extensions, one of the best ways to
-learn more about this is to look at other similar extensions to see
-how they work. You'll probably also need to read various API docs,
-including the docs for the various C<Moose::Meta::*> and
-C<Class::MOP::*> classes.
-
-Finally, we welcome questions on the Moose mailing list and
-IRC. Information on the mailing list, IRC, and more references can be
-found in the L<Moose.pm docs|Moose/GETTING HELP>.
-
-=head1 AUTHORS
-
-=over 4
-
-=item *
-
-Stevan Little <stevan@cpan.org>
-
-=item *
-
-Dave Rolsky <autarch@urth.org>
-
-=item *
-
-Jesse Luehrs <doy@cpan.org>
-
-=item *
-
-Shawn M Moore <sartak@cpan.org>
-
-=item *
-
-יובל קוג'מן (Yuval Kogman) <nothingmuch@woobling.org>
-
-=item *
-
-Karen Etheridge <ether@cpan.org>
-
-=item *
-
-Florian Ragwitz <rafl@debian.org>
-
-=item *
-
-Hans Dieter Pearcey <hdp@cpan.org>
-
-=item *
-
-Chris Prather <chris@prather.org>
-
-=item *
-
-Matt S Trout <mstrout@cpan.org>
-
-=back
-
-=head1 COPYRIGHT AND LICENSE
-
-This software is copyright (c) 2006 by Infinity Interactive, Inc.
-
-This is free software; you can redistribute it and/or modify it under
-the same terms as the Perl 5 programming language system itself.
-
-=cut

data/lib/javonet-ruby-sdk/Binaries/Perl/MacOs/X64/deps/lib/perl5/darwin-thread-multi-2level/Moose/Manual/MethodModifiers.pod

@@ -1,449 +0,0 @@
-# PODNAME: Moose::Manual::MethodModifiers
-# ABSTRACT: Moose's method modifiers
-
-__END__
-
-=pod
-
-=encoding UTF-8
-
-=head1 NAME
-
-Moose::Manual::MethodModifiers - Moose's method modifiers
-
-=head1 VERSION
-
-version 2.2207
-
-=head1 WHAT IS A METHOD MODIFIER?
-
-Moose provides a feature called "method modifiers". You can also think
-of these as "hooks" or "advice".
-
-It's probably easiest to understand this feature with a few examples:
-
-  package Example;
-
-  use Moose;
-
-  sub foo {
-      print "    foo\n";
-  }
-
-  before 'foo' => sub { print "about to call foo\n"; };
-  after 'foo'  => sub { print "just called foo\n"; };
-
-  around 'foo' => sub {
-      my $orig = shift;
-      my $self = shift;
-
-      print "  I'm around foo\n";
-
-      $self->$orig(@_);
-
-      print "  I'm still around foo\n";
-  };
-
-Now if I call C<< Example->new->foo >> I'll get the following output:
-
-  about to call foo
-    I'm around foo
-      foo
-    I'm still around foo
-  just called foo
-
-You probably could have figured that out from the names "before",
-"after", and "around".
-
-Also, as you can see, the before modifiers come before around
-modifiers, and after modifiers come last.
-
-When there are multiple modifiers of the same type, the before and
-around modifiers run from the last added to the first, and after
-modifiers run from first added to last:
-
-   before 2
-    before 1
-     around 2
-      around 1
-       primary
-      around 1
-     around 2
-    after 1
-   after 2
-
-=head1 WHY USE THEM?
-
-Method modifiers have many uses. They are often used in roles to alter the
-behavior of methods in the classes that consume the role. See
-L<Moose::Manual::Roles> for more information about roles.
-
-Since modifiers are mostly useful in roles, some of the examples below
-are a bit artificial. They're intended to give you an idea of how
-modifiers work, but may not be the most natural usage.
-
-=head1 BEFORE, AFTER, AND AROUND
-
-Method modifiers can be used to add behavior to methods without modifying the definition of those methods.
-
-=head2 Before and after Modifiers
-
-Method modifiers can be used to add behavior to a method that Moose
-generates for you, such as an attribute accessor:
-
-  has 'size' => ( is => 'rw' );
-
-  before 'size' => sub {
-      my $self = shift;
-
-      if (@_) {
-          Carp::cluck('Someone is setting size');
-      }
-  };
-
-Another use for the before modifier would be to do some sort of
-prechecking on a method call. For example:
-
-  before 'size' => sub {
-      my $self = shift;
-
-      die 'Cannot set size while the person is growing'
-          if @_ && $self->is_growing;
-  };
-
-This lets us implement logical checks that don't make sense as type
-constraints. In particular, they're useful for defining logical rules
-about an object's state changes.
-
-Similarly, an after modifier could be used for logging an action that
-was taken.
-
-Note that the return values of both before and after modifiers are
-ignored.
-
-=head2 Around modifiers
-
-An around modifier is more powerful than either a before or
-after modifier. It can modify the arguments being passed to the
-original method, and you can even decide to simply not call the
-original method at all. You can also modify the return value with an
-around modifier.
-
-An around modifier receives the original method as its first argument,
-I<then> the object, and finally any arguments passed to the method.
-
-  around 'size' => sub {
-      my $orig = shift;
-      my $self = shift;
-
-      return $self->$orig()
-          unless @_;
-
-      my $size = shift;
-      $size = $size / 2
-          if $self->likes_small_things();
-
-      return $self->$orig($size);
-  };
-
-=head2 Wrapping multiple methods at once
-
-C<before>, C<after>, and C<around> can also modify multiple methods
-at once. The simplest example of this is passing them as a list:
-
-  before [qw(foo bar baz)] => sub {
-      warn "something is being called!";
-  };
-
-This will add a C<before> modifier to each of the C<foo>, C<bar>,
-and C<baz> methods in the current class, just as though a separate
-call to C<before> was made for each of them. The list can be passed
-either as a bare list, or as an arrayref. Note that the name of the
-function being modified isn't passed in in any way; this syntax is
-only intended for cases where the function being modified doesn't
-actually matter. If the function name does matter, use something like this:
-
-  for my $func (qw(foo bar baz)) {
-      before $func => sub {
-          warn "$func was called!";
-      };
-  }
-
-=head2 Using regular expressions to select methods to wrap
-
-In addition, you can specify a regular expression to indicate the
-methods to wrap, like so:
-
-  after qr/^command_/ => sub {
-      warn "got a command";
-  };
-
-This will match the regular expression against each method name
-returned by L<Class::MOP::Class/get_method_list>, and add a modifier
-to each one that matches. The same caveats apply as above.
-
-Using regular expressions to determine methods to wrap is quite a bit more
-powerful than the previous alternatives, but it's also quite a bit more
-dangerous.  Bear in mind that if your regular expression matches certain Perl
-and Moose reserved method names with a special meaning to Moose or Perl, such
-as C<meta>, C<new>, C<BUILD>, C<DESTROY>, C<AUTOLOAD>, etc, this could cause
-unintended (and hard to debug) problems and is best avoided.
-
-=head2 Execution order of method modifiers and inheritance
-
-When both a superclass and an inheriting class have the same method modifiers,
-the method modifiers of the inheriting class are wrapped around the method
-modifiers of the superclass, as the following example illustrates:
-
-Here is the parent class:
-
-  package Superclass;
-  use Moose;
-  sub rant { printf "        RANTING!\n" }
-  before 'rant' => sub { printf "    In %s before\n", __PACKAGE__ };
-  after 'rant'  => sub { printf "    In %s after\n",  __PACKAGE__ };
-  around 'rant' => sub {
-      my $orig = shift;
-      my $self = shift;
-      printf "      In %s around before calling original\n", __PACKAGE__;
-      $self->$orig;
-      printf "      In %s around after calling original\n", __PACKAGE__;
-  };
-  1;
-
-And the child class:
-
-  package Subclass;
-  use Moose;
-  extends 'Superclass';
-  before 'rant' => sub { printf "In %s before\n", __PACKAGE__ };
-  after 'rant'  => sub { printf "In %s after\n",  __PACKAGE__ };
-  around 'rant' => sub {
-      my $orig = shift;
-      my $self = shift;
-      printf "  In %s around before calling original\n", __PACKAGE__;
-      $self->$orig;
-      printf "  In %s around after calling original\n", __PACKAGE__;
-  };
-  1;
-
-And here's the output when we call the wrapped method (C<< Child->rant >>):
-
-  % perl -MSubclass -e 'Subclass->new->rant'
-
-  In Subclass before
-    In Subclass around before calling original
-      In Superclass before
-        In Superclass around before calling original
-          RANTING!
-        In Superclass around after calling original
-      In Superclass after
-    In Subclass around after calling original
-  In Subclass after
-
-=head1 INNER AND AUGMENT
-
-Augment and inner are two halves of the same feature. The augment
-modifier provides a sort of inverted subclassing. You provide part of
-the implementation in a superclass, and then document that subclasses
-are expected to provide the rest.
-
-The superclass calls C<inner()>, which then calls the C<augment>
-modifier in the subclass:
-
-  package Document;
-
-  use Moose;
-
-  sub as_xml {
-      my $self = shift;
-
-      my $xml = "<document>\n";
-      $xml .= inner();
-      $xml .= "</document>\n";
-
-      return $xml;
-  }
-
-Using C<inner()> in this method makes it possible for one or more
-subclasses to then augment this method with their own specific
-implementation:
-
-  package Report;
-
-  use Moose;
-
-  extends 'Document';
-
-  augment 'as_xml' => sub {
-      my $self = shift;
-
-      my $xml = "  <report>\n";
-      $xml .= inner();
-      $xml .= "  </report>\n";
-
-      return $xml;
-  };
-
-When we call C<as_xml> on a Report object, we get something like this:
-
-  <document>
-    <report>
-    </report>
-  </document>
-
-But we also called C<inner()> in C<Report>, so we can continue
-subclassing and adding more content inside the document:
-
-  package Report::IncomeAndExpenses;
-
-  use Moose;
-
-  extends 'Report';
-
-  augment 'as_xml' => sub {
-      my $self = shift;
-
-      my $xml = '    <income>' . $self->income . '</income>';
-      $xml .= "\n";
-      $xml .= '    <expenses>' . $self->expenses . '</expenses>';
-      $xml .= "\n";
-
-      $xml .= inner() || q{};
-
-      return $xml;
-  };
-
-Now our report has some content:
-
-  <document>
-    <report>
-      <income>$10</income>
-      <expenses>$8</expenses>
-    </report>
-  </document>
-
-What makes this combination of C<augment> and C<inner()> special is
-that it allows us to have methods which are called from parent (least
-specific) to child (most specific). This inverts the normal
-inheritance pattern.
-
-Note that in C<Report::IncomeAndExpenses> we call C<inner()> again. If the
-object is an instance of C<Report::IncomeAndExpenses> then this call is a
-no-op, and just returns false. It's a good idea to always call C<inner()> to
-allow for future subclassing.
-
-=head1 OVERRIDE AND SUPER
-
-Finally, Moose provides some simple sugar for Perl's built-in method
-overriding scheme. If you want to override a method from a parent
-class, you can do this with C<override>:
-
-  package Employee;
-
-  use Moose;
-
-  extends 'Person';
-
-  has 'job_title' => ( is => 'rw' );
-
-  override 'display_name' => sub {
-      my $self = shift;
-
-      return super() . q{, } . $self->job_title();
-  };
-
-The call to C<super()> is almost the same as calling C<<
-$self->SUPER::display_name >>. The difference is that the arguments
-passed to the superclass's method will always be the same as the ones
-passed to the method modifier, and cannot be changed.
-
-All arguments passed to C<super()> are ignored, as are any changes
-made to C<@_> before C<super()> is called.
-
-=head1 SEMI-COLONS
-
-Because all of these method modifiers are implemented as Perl
-functions, you must always end the modifier declaration with a
-semi-colon:
-
-  after 'foo' => sub { };
-
-=head1 EXCEPTIONS AND STACK TRACES
-
-An exception thrown in a C<before> modifier will prevent the method it
-modifies from being called at all. An exception in an C<around> modifier may
-prevent the modified method from being called, depending on how the C<around>
-modifier is structured. An exception in an C<after> modifier obviously cannot
-prevent the method it wraps from being called.
-
-Both C<override> and C<augment> are similar to C<around> in that they can
-decide whether or not to call the method they modify before or after throwing
-an exception.
-
-From the caller's perspective, an exception in a method modifier will look
-like the method it called threw an exception. However, method modifiers are
-just standard Perl subroutines. This means that they end up on the stack in
-stack traces as an additional frame.
-
-=head1 CAVEATS
-
-These method modification features do not work well with multiple inheritance,
-due to how method resolution is performed in Perl. Experiment with a test
-program to ensure your class hierarchy works as expected, or more preferably,
-don't use multiple inheritance (roles can help with this)!
-
-=head1 AUTHORS
-
-=over 4
-
-=item *
-
-Stevan Little <stevan@cpan.org>
-
-=item *
-
-Dave Rolsky <autarch@urth.org>
-
-=item *
-
-Jesse Luehrs <doy@cpan.org>
-
-=item *
-
-Shawn M Moore <sartak@cpan.org>
-
-=item *
-
-יובל קוג'מן (Yuval Kogman) <nothingmuch@woobling.org>
-
-=item *
-
-Karen Etheridge <ether@cpan.org>
-
-=item *
-
-Florian Ragwitz <rafl@debian.org>
-
-=item *
-
-Hans Dieter Pearcey <hdp@cpan.org>
-
-=item *
-
-Chris Prather <chris@prather.org>
-
-=item *
-
-Matt S Trout <mstrout@cpan.org>
-
-=back
-
-=head1 COPYRIGHT AND LICENSE
-
-This software is copyright (c) 2006 by Infinity Interactive, Inc.
-
-This is free software; you can redistribute it and/or modify it under
-the same terms as the Perl 5 programming language system itself.
-
-=cut