MooseX::TransactionalMethods exports the "transactional" declarator that will
enclose the method in a txn_do call.
Object::Destroyer allows for the creation of "Destroy" handles. The
handle is "attached" to the circular relationship, but is not a part
of it. When the destroy handle falls out of scope, it will be cleaned
up correctly, and while being cleaned up, it will also force the data
structure it is attached to be destroyed as well. Object::Destroyer
can call a specified release method on an object (or method DESTROY by
default). Alternatively, it can execute an arbitrary user code passed
to constructor as a code reference.
This module lets you call methods of a certain object more easily
by exporting them as functions to a package. The exported functions
are not called as methods and do not receive an object argument,
but instead the object is fixed at the time you import them with
this module.
Object::Signature is an abstract base class that you can inherit from in
order to allow your objects to generate unique cryptographic signatures.
The method used to generate the signature is based on Storable and
Digest::MD5. The object is fed to Storable::nfreeze to get a string,
which is then passed to Digest::MD5::md5_hex to get a unique 32
character hexadecimal signature.
There's a whole bunch of class builders out there. In fact, creating a
class builder seems to be something of a rite of passage (this is my
fifth, at least).
Unfortunately, most of the time I want a class builder I'm in a hurry
and sketching out lots of fairly simple data classes with fairly
simple structure, mostly just read-only accessors, and that's about it.
Often this is for code that won't end up on CPAN, so adding a small
dependency doesn't matter much. I just want to be able to define these
classes FAST.
By which I mean LESS typing than writing them by hand, not more. And I
don't need all those weird complex features that bloat out the code
and take over the whole way I build modules.
And so, I present yet another member of the Tiny family of modules,
Object::Tiny.
More Opcodes information from opnames.h and opcode.h
The canonical list of operator names is the contents of the array
PL_op_name, defined and initialised in file opcode.h of the Perl
source distribution (and installed into the perl library).
Each operator has both a terse name (its opname) and a more verbose or
recognisable descriptive name. The opdesc function can be used to
return a description for an OP.
This module creates and manipulates PAR distributions. They are
architecture-specific PAR files, containing everything under blib/
of CPAN distributions after their "make" or "Build" stage, a META.yml
describing metadata of the original CPAN distribution, and a MANIFEST
detailing all files within it. Digitally signed PAR distributions
will also contain a SIGNATURE file.
The naming convention for such distributions is:
$NAME-$VERSION-$ARCH-$PERL_VERSION.par
For example, "PAR-Dist-0.01-i386-freebsd-5.8.0.par" corresponds to the
0.01 release of "PAR-Dist" on CPAN, built for perl 5.8.0 running on
"i386-freebsd".
The types provided with Moose are by design global. This package helps you to
organise and selectively import your own and the built-in types in libraries.
As a nice side effect, it catches typos at compile-time too.
However, the main reason for this module is to provide an easy way to not have
conflicts with your type names, since the internal fully qualified names of the
types will be prefixed with the library's name.
This module will also provide you with some helper functions to make it easier
to use Moose types in your code.
Extend your attribute interfaces
This is an abstract role which provides an alternate constructor
for creating objects using parameters passed in from a configuration file.
The actual implementation of reading the configuration file is
left to concrete subroles.