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

FreeBSD Manual Pages


home | help
MakeMethods::Docs::ToDUser Contributed Perl DocumentMakeMethods::Docs::ToDo(3)

       Class::MakeMethods::Docs::ToDo -	Ideas, problems, and suggestions

       There are lots of things	that could be done to improve this module.

       Issues about the	distribution and supporting files, rather than the

       o   Make	sure that the documentation is broken up into appropriately-
	   sized chunks, and that people will know which section to look at.

       o   As user questions arrive, add the answers as	documentation points
	   or examples.

       o   Assemble annotated examples and tutorials, and either link to or
	   distribute them.

       o   Finish overhauling Template documentation.

       o   Include Global and InsideOut	uses in	the EXAMPLES section

       o   Template Internals: Finish documenting disk-based meta-method code-

       o   Use Devel::Coverage to measure test coverage, and fill in missing

       o   Finish tests	for Standard and Composite modules.

       o   It does not appear to be possible to	assign subroutine names	to
	   closures within Perl. As a result, debugging	output from Carp and
	   similar sources will	show all generated methods as "ANON()" rather
	   than	"YourClass::methodname()".

	   UPDATE: There now seem to be	fixes for this which should be
	   integrated: See the new Sub::Name module and

       o   For scalar methods (and others) it would be nice to have a simple
	   bounds-checking interface to	approve	or reject (with	an exception)
	   new values that were	passed in.

	   As pointed out by Terrence Brannon, the right interface to adopt is
	   probably that of Attribute::Types:

	     use Class::MakeMethods::Standard::Hash (
	       'scalar'	=> [ 'count' =>	{ TYPE => 'INTEGER' } ],
	       'scalar'	=> [ 'name' => { TYPE => qr/^[A-Z]\w*$/	} ],
	       'scalar'	=> [ 'account' => { TYPE => &checksum_account_number } ]

       o   Improve use of _diagnostic hooks for	debugging. Add various "(Q)"
	   debug diagnostics.

       o   Finish building Inheritable array and object	accessors.

       o   Finish building Composite::*	packages.

       o   Resolve DESTROY-time	issues with Standard::Inheritable,
	   Composite::Inheritable, and Template::InsideOut.

       o   Add slice and splice	functionality to Standard::*:hash and

       o   Allow untyped object	accesors if "class" attribute is not set.
	   (Suggested in Jan-01	NY Perl	Seminar	discussion.)

       o   Standardize naming templates	for array, hash, other method types.

	   Deprecate verb_x methods? Or	at last	make them consistently
	   available both ways.

	   Make	list methods consistent	with hash_of_lists methods, in action,
	   and in name (x_verb).  Also for others (e.g., set_ clear_ boolean)

       o   Should default object template provide auto-create behavior on

       o   Generalize the "Generic:scalar -init_and_get" interface to support
	   memoizing values for	other accessor types.

       o   Consider adding hash	each and array iterator	methods, using a
	   closure to provide iteration.

       o   Add support for tied	arrays & scalars, a la tiedhash

       o   Add string_multiple_index.

       o   Extend index	methods	to support weak	indexes	with WeakRef. Perhaps
	   just	have it	accept a hash ref to use as the	index, and then	allow
	   people to pass in tied hashes?

       o   Maybe make private or protected method croak	if they	were called by
	   a method_init method	which was called by an outside package.

	   Not entirely	clear what the right semantics or security precautions
	   are here...

   Template::Generic Subclasses
       o   Finish building code_or_scalar meta-method.

       o   Finish building Class::MakeMethods::ClassInherit subclass.

	   Need	to work	out how	to capture changes for non-scalar values. For
	   example, if a subclass inherits an array accessor and then pops it,
	   is there some way to	provide	them with copy-on-write?

       o   Add enumerated string/number	type.

	   Provide helper methods with map of associated values	(ex $o->port =
	   80 ... $o->port_readable eq 'HTTP' ). Cf. code for earlier
	   unpublished 'lookup'	method type.

       o   For StructBuiltin:

	   Add -fatal flag to die if core func returns false / undef Add call
	   method to recall method with	alternative arguments.	Add -nocall
	   flag	to not call core func on new.

       o   Replace ClassName:static_hash_classname with	Class:indexed_string.

   Template Internals
       o   Figure out which modules, if	any, should actually be	using
	   AutoLoader.	Probably just Template::Generic?

       o   Give	users a	way to do meta-method code-caching in Perl library
	   hierarchy, rather than in /tmp/auto or other	user-specified

	   Provide mechanism for pre-generating	these at install time.

	   Perhaps load	these via do, rather than open/read/eval?

	   Perhaps pre-generate	expanded libs with all of the -imports

       o   Support generating code files and loading them as needed.

	   This	would be similar to Class::Classgen, except that we'd do the
	   generation at run-time the first time it was	required, rather than
	   in a	separate pass.

	   For example,	given the following declaration:

	     package Foo::Bar;
	     Class::MakeMethods::Template::Hash->import(-codecache=>'auto', scalar=>'foo');

	   We should be	able to	write out the following	file:

	     cat 'auto/Foo/Bar/'
	     # NOTE: Generated for Foo::Bar by the Class::MakeMethods module.
	     # Changes made here will be lost when Foo::Bar is modified.
	     package Foo::Bar;
	     sub foo {
	       my $self	= shift;
	       if ( scalar @_ )	{
		 $self->{'foo'}	= shift();

	   Then	on subsequent uses, we can just	re-load	the generated code:

	     require "auto/Foo/Bar/";

	   To do this, we need to:

	   o   Provide an option to select this	if desired; maybe ...
	       import('-cache' => 'auto/', ...)?

	   o   Figure out which	directory we can/should	write into.

	   o   Re-evaluate the textual code templates, without generating the
	       closures. Substitute in any _STATIC_ATTR_ values. Make other
	       _ATTR_ values point to some public lookup table or package

	   o   Notice if the source file (or Class::MakeMethods	modules) has
	       been updated more recently than the generated file.

       See Class::MakeMethods for general information about this distribution.

perl v5.24.1			  2004-09-06	    MakeMethods::Docs::ToDo(3)


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

home | help