Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
Class::InsideOut::ManuUserAContributed Perl Class::InsideOut::Manual::About(3)

       Class::InsideOut::Manual::About - guide to this and other
       implementations of the inside-out technique

       version 1.14

       This manual provides an overview	of the inside-out technique and	its
       application within "Class::InsideOut" and other modules.	 It also
       provides	a list of references for further study.

   Inside-out object basics
       Inside-out objects use the blessed reference as an index	into lexical
       data structures holding object properties, rather than using the
       blessed reference itself	as a data structure.

	 $self->{ name }	= "Larry"; # classic, hash-based object
	 $name{	refaddr	$self }	= "Larry"; # inside-out

       The inside-out approach offers three major benefits:

       o   Enforced encapsulation: object properties cannot be accessed
	   directly from outside the lexical scope that	declared them

       o   Making the property name part of a lexical variable rather than a
	   hash-key means that typos in	the name will be caught	as compile-
	   time	errors (if using strict)

       o   If the memory address of the	blessed	reference is used as the
	   index, the reference	can be of any type

       In exchange for these benefits, robust implementation of	inside-out
       objects can be quite complex.  "Class::InsideOut" manages that

   Philosophy of "Class::InsideOut"
       "Class::InsideOut" provides a set of tools for building safe inside-out
       classes with maximum flexibility.

       It aims to offer	minimal	restrictions beyond those necessary for
       robustness of the inside-out technique.	All capabilities necessary for
       robustness should be automatic.	Anything that can be optional should
       be.  The	design should not introduce new	restrictions unrelated to
       inside-out objects, such	as attributes and "CHECK" blocks that cause
       problems	for "mod_perl" or the use of source filters for	syntactic

       As a result, only a few things are mandatory:

       o   Properties must be based on hashes and declared via "property"

       o   Property hashes must	be keyed on the	"Scalar::Util::refaddr"

       o   "register" must be called on	all new	objects

       All other implementation	details, including constructors, initializers
       and class inheritance management	are left to the	user (though a very
       simple constructor is available as a convenience).  This	does requires
       some additional work, but maximizes freedom.  "Class::InsideOut"	is
       intended	to be a	base class providing only fundamental features.
       Subclasses of "Class::InsideOut"	could be written that build upon it to
       provide particular styles of constructor, destructor and	inheritance

   Other modules on CPAN
       o   Object::InsideOut --	This is	perhaps	the most full-featured,	robust
	   implementation of inside-out	objects	currently on CPAN.  It is
	   highly recommended if a more	full-featured inside-out object
	   builder is needed.  Its array-based mode is faster than hash-based
	   implementations, but	black-box inheritance is handled via
	   delegation, which imposes certain limitations.

       o   Class::Std -- Despite the name, this	does not reflect currently
	   known best practices	for inside-out objects.	 Does not provide
	   thread-safety with CLONE and	doesn't	support	black-box inheritance.
	   Has a robust	inheritance/initialization system.

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

       o   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. Not thread-safe.

       o   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.

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

   References for further study
       Much of the Perl	community discussion of	inside-out objects has taken
       place on	Perlmonks (<>).  My	scratchpad there has a
       fairly comprehensive list of articles
       (<>).  Some of the more
       informative articles include:

       o   Abigail-II. "Re: Where/When is OO useful?". July 1, 2002.

       o   Abigail-II. "Re: Tutorial: Introduction to Object-Oriented
	   Programming".  December 11, 2002.

       o   demerphq. "Yet Another Perl Object Model (Inside Out	Objects)".
	   December 14,	2002. <>

       o   xdg.	"Threads and fork and CLONE, oh	my!". August 11, 2005.

       o   jdhedden. "Anti-inside-out-object-ism". December 9, 2005.

       o   Class::InsideOut

       o   Class::InsideOut::Manual::Advanced

       David Golden <>

       This software is	Copyright (c) 2006 by David A. Golden.

       This is free software, licensed under:

	 The Apache License, Version 2.0, January 2004

perl v5.32.1			  2017-04-02Class::InsideOut::Manual::About(3)


Want to link to this manual page? Use this URL:

home | help