This is the GNU Debugger GDB, configured for the AVR microcontroller
target.
This debugger cannot really be used standalone, but is useful in
connection with either AVaRICE (http://avarice.sourceforge.net/)
or simulavr (http://www.freesoftware.fsf.org/simulavr/).
avra is an GNU GPL'ed assembler for the Atmel AVR microcontrollers.
See the file COPYING for more information regarding the license.
Class::Mixin provides a way to mix methods from one class into another,
such that the target class can use both its methods as well as those of
the source class.
The primary advantage is that the behavior of a class can be modified
to effectively be another class without changing any of the calling
code -- just requires using the new class that mixes into the original.
You can define multimethods with the "multi" declarator:
use Class::Multimethods::Pure;
multi collide => ('Bullet', 'Ship') => sub {
my ($a, $b) = @_; ...
};
multi collide => ('Ship', 'Asteroid') => sub {
my ($a, $b) = @_; ...
};
It is usually wise to put such declarations within a BEGIN block, so
they behave more like Perl treats subs (you can call them without
parentheses and you can use them before you define them).
Add Catalyst-Style Config To Your Class
Class::Default provides a mechanism to allow your class to take static
method calls and apply it to a default instantiation of an object. It
provides a flexibility to an API that allows it to be used more
comfortably in different situations.
This technique appears to be especially useful when writing modules
that you want to be used in either a single use or a persistent
environment. In a CGI like environment, you want the simplicity of a
static interface. You can call Class-method> directly, without having
to pass an instantiation around constantly.
Class::ErrorHandler provides an error-handling mechanism that's
generic enough to be used as the base class for a variety of OO
classes.
Class::OOorNO
Class::OOorNO helps your module handle the input for its subroutines
whether called in object-oriented style (as object methods or class
methods with the arrow syntax ->), or in functional programming style
(as subroutines imported to the caller's namespace via Exporter).
Class::Generate is a Perl5 module to simplify creating class
hierarchies. It offers typed or untyped scalar, array, and hash
members, required members, private members, methods (both
instance and class), and other common features of object-
oriented software development. Of course, you can implement all
these things without a special module, but doing it via
Class::Generate is much, much more concise. And furthermore,
it's much less error prone: if you are using Perl's -w flag,
Class::Generate will catch many class specification and usage
errors.
Class related functionality in Perl is broken up into a variety of
different modules. Class::Handle attempts to provide a convenient
object wrapper around the various different types of functions that can
be performed on a class.
Currently, Class::Handle provides what is effectively a combined API from
UNIVERSAL, Class::ISA and Class::Inspector for obtaining information
about a Class, and some additional task methods, such as load to common
tasks relating to classes.