NAME
    Class::InsideOut - a safe, simple inside-out object construction kit

SYNOPSIS
     package My::Class;
 
     use Class::InsideOut qw( property register );
     use Scalar::Util qw( refaddr );

     # declare a lexical property hash with 'my'
     property my %name; 

     sub new {
       my $class = shift;
       my $self = \do {my $scalar};
       bless $self, $class;
   
       # register the object for thread-safety
       register( $self ); 
     }

     sub name {
       my $self = shift;
       if ( @_ ) { 
   
         # use 'refaddr' to access properties for an object
         $name{ refaddr $self } = shift;
     
         return $self;
       }
       return $name{ refaddr $self };
     }
 
     sub greeting {
       my $self = shift;
       print "Hello, my name is " . $name { refaddr $self } . "\n";
     }

DESCRIPTION
    This is an alpha release for a work in progress. It is a functional but
    incomplete implementation of a simple, safe and streamlined toolkit for
    building inside-out objects. Unlike most other inside-out object
    building modules already on CPAN, this module aims for minimalism and
    robustness. It uses no source filters, no attributes, supports foreign
    inheritance, does not leak memory, is overloading-safe, is thread-safe
    for Perl 5.8 or better and should be mod_perl compatible.

    In its current state, it provides the minimal support necessary for safe
    inside-out objects. All other implementation details, including writing
    a constructor and accessors, are left to the user. Future versions will
    add basic accessor support and serialization support.

  Inside-out object basics

    To be written.

USAGE
  Importing `Class::InsideOut'

    To be written.

  Declaring and accessing object properties

    To be written.

  Object destruction

    To be written.

  Foreign inheritance

    To be written.

  Serialization

    To be written.

  Thread-safety

    To be written.

FUNCTIONS
  `property'

      property my %name;

    Declares an inside-out property. The argument must be a lexical hash,
    though the `my' keyword can be included as part of the argument rather
    than as a separate statement. No accessor is created, but the property
    will be tracked for memory cleanup during object destruction and for
    proper thread-safety.

  `register'

      register $object;

    Registers an object for thread-safety. This should be called as part of
    a constructor on a object blessed into the current package. Returns the
    object (without modification).

  `CLONE'

    `CLONE' is automatically exported to provide thread-safety to modules
    using `Class::InsideOut'. See perlmod for details. It will be called
    automatically by Perl if threads are in use and a new interpreter thread
    is created. It should never be called directly.

  `DESTROY'

    This destructor is automatically exported to modules using
    `Class::InsideOut' to clean up object property memory usage during
    object destruction. It should never be called directly. In the future,
    it will be enhanced to support a user supplied `DEMOLISH' method for
    additional, custom destruction actions.

SEE ALSO
    *   Object::InsideOut -- Currently the most full-featured, robust
        implementation of inside-out objects, but foreign inheritance is
        handled via delegation. Highly recommended if a more full-featured
        inside-out object builder is needed.

    *   Class::Std -- Despite the name, does not reflect best practices for
        inside-out objects. Does not provide thread-safety with CLONE, is
        not mod_perl safe and doesn't support foreign inheritance.

    *   Class::BuildMethods -- Generates accessors with encapsulated storage
        using a flyweight inside-out variant. Lexicals properties are
        hidden; accessors must be used everywhere.

    *   Lexical::Attributes -- The original inside-out implementation, but
        missing some key features like thread-safety. Also, uses source
        filters to provide Perl-6-like object syntax.

    *   Class::MakeMethods::Templates::InsideOut -- Not a very robust
        implementation. Not thread-safe. Not overloading-safe. Has a steep
        learning curve for the Class::MakeMethods system.

    *   Object::LocalVars -- My own original thought experiment with
        'outside-in' objects and local variable aliasing. Not
        production-safe and offers very weak encapsulation.

BUGS
    Please report bugs using the CPAN Request Tracker at
    http://rt.cpan.org/NoAuth/Bugs.html?Dist=Class-InsideOut

    When submitting a bug or request, please include a test-file or a patch
    to an existing test-file that illustrates the bug or desired feature.

AUTHOR
    David A. Golden (DAGOLDEN)

    dagolden@cpan.org

    http://dagolden.com/

COPYRIGHT
    Copyright (c) 2006 by David A. Golden

    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.