/ 
Object-Tiny-1.02
River stage two • 45 direct dependents • 70 total dependents
/ Object::Tiny

NAME

Object::Tiny - Class building as simple as it gets

SYNOPSIS

# Define a class
package Foo;

use Object::Tiny qw{ bar baz };

1;
 

# Use the class
my $object = Foo->new( bar => 1 );

print "bar is " . $object->bar . "\n";

DESCRIPTION

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.

The goal here is really just to save me some typing. There's others that could do the job just fine, but I want something that does as little as possible and creates code the same way I'd have written it by hand anyway.

To use Object::Tiny, just call it with a list of accessors to be created.

use Object::Tiny 'foo', 'bar';

For a large list, I lay it out like this...

use Object::Tiny qw{
    item_font_face
    item_font_color
    item_font_size
    item_text_content
    item_display_time
    seperator_font_face
    seperator_font_color
    seperator_font_size
    seperator_text_content
    };

This will create a bunch of simple accessors, and set the inheritance to be the child of Object::Tiny.

Object::Tiny is empty other than a basic new constructor which does the following

sub new {
    my $class = shift;
    return bless { @_ }, $class;
}

In fact, if doing the following in your class gets annoying...

sub new {
    my $class = shift;
    my $self  = $class->SUPER::new( @_ );

    # Extra checking and such
    ...

    return $self;
}

... then feel free to ditch the SUPER call and just create the hash yourself! It's not going to make a lick of different and there's nothing magic going on under the covers you might break.

And that's really all there is to it. Let a million simple data classes bloom. Features? We don't need no stinking features.

Handling Subclasses

If the class you are using Object::Tiny for is already a subclass of another Object::Tiny class (or a subclass of anything else) it doesn't really work to make the class use multiple inheritance.

So in this case, Object::Tiny will create the accessors you specify, but WON'T make it a subclass of Object::Tiny.

SUPPORT

Bugs should be reported via the CPAN bug tracker at

http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Object-Tiny

For other issues, contact the author.

AUTHOR

Adam Kennedy <adamk@cpan.org>

SEE ALSO

Config::Tiny

COPYRIGHT

Copyright 2007 Adam Kennedy.

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

The full text of the license can be found in the LICENSE file included with this module.