/usr/share/perl5/Class/Virtual.pm is in libclass-virtual-perl 0.08-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 | package Class::Virtual;
use strict;
use warnings;
use vars qw($VERSION @ISA);
$VERSION = '0.08';
use Carp::Assert qw(DEBUG); # import only the tiny bit we need so it doesn't
# get inherited.
use Class::ISA;
use Class::Data::Inheritable;
@ISA = qw(Class::Data::Inheritable);
__PACKAGE__->mk_classdata('__Virtual_Methods');
=pod
=head1 NAME
Class::Virtual - Base class for virtual base classes.
=head1 SYNOPSIS
package My::Virtual::Idaho;
use base qw(Class::Virtual);
__PACKAGE__->virtual_methods(qw(new foo bar this that));
package My::Private::Idaho;
use base qw(My::Virtual::Idaho);
# Check to make sure My::Private::Idaho implemented everything
my @missing = __PACKAGE__->missing_methods;
die __PACKAGE__ . ' forgot to implement ' . join ', ', @missing
if @missing;
# If My::Private::Idaho forgot to implement new(), the program will
# halt and yell about that.
my $idaho = My::Private::Idaho->new;
# See what methods we're obligated to implement.
my @must_implement = __PACKAGE__->virtual_methods;
=head1 DESCRIPTION
B<THIS MODULE IS DISCOURAGED!> Avoid using it for new code. There's
nothing wrong with it, but there are better ways to accomplish the
same thing. Look into the L<Moose> ecosystem.
This is a base class for implementing virtual base classes (what some
people call an abstract class). Kinda kooky. It allows you to
explicitly declare what methods are virtual and that must be
implemented by subclasses. This might seem silly, since your program
will halt and catch fire when an unimplemented virtual method is hit
anyway, but there's some benefits.
The error message is more informative. Instead of the usual
"Can't locate object method" error, you'll get one explaining that a
virtual method was left unimplemented.
Subclass authors can explicitly check to make sure they've implemented
all the necessary virtual methods. When used as part of a regression
test, it will shield against the virtual method requirements changing
out from under the subclass.
Finally, subclass authors can get an explicit list of everything
they're expected to implement.
Doesn't hurt and it doesn't slow you down.
=head2 Methods
=over 4
=item B<virtual_methods>
Virtual::Class->virtual_methods(@virtual_methods);
my @must_implement = Sub::Class->virtual_methods;
This is an accessor to the list of virtual_methods. Virtual base
classes will declare their list of virtual methods. Subclasses will
look at them. Once the virtual methods are set they cannot be undone.
=for notes
I'm tempted to make it possible for the subclass to override the
virtual methods, perhaps add to them. Too hairy to think about for
0.01.
=cut
#"#
sub virtual_methods {
my($class) = shift;
if( @_ ) {
if( defined $class->__Virtual_Methods ) {
require Carp;
Carp::croak("Attempt to reset virtual methods.");
}
$class->_mk_virtual_methods(@_);
}
else {
return @{$class->__Virtual_Methods};
}
}
sub _mk_virtual_methods {
no strict 'refs'; # symbol table mucking! Getcher goloshes on.
my($this_class, @methods) = @_;
$this_class->__Virtual_Methods(\@methods);
# private method to return the virtual base class
*{$this_class.'::__virtual_base_class'} = sub {
return $this_class;
};
foreach my $meth (@methods) {
# Make sure the method doesn't already exist.
if( $this_class->can($meth) ) {
require Carp;
Carp::croak("$this_class attempted to declare $meth() virtual ".
"but it appears to already be implemented!");
}
# Create a virtual method.
*{$this_class.'::'.$meth} = sub {
my($self) = shift;
my($class) = ref $self || $self;
require Carp;
if( $class eq $this_class) {
my $caller = caller;
Carp::croak("$caller called the virtual base class ".
"$this_class directly! Use a subclass instead");
}
else {
Carp::croak("$class forgot to implement $meth()");
}
};
}
}
=pod
=item B<missing_methods>
my @missing_methods = Sub::Class->missing_methods;
Returns a list of methods Sub::Class has not yet implemented.
=cut
sub missing_methods {
my($class) = shift;
my @vmeths = $class->virtual_methods;
my @super_classes = Class::ISA::self_and_super_path($class);
my $vclass = $class->__virtual_base_class;
# Remove everything in the hierarchy beyond, and including,
# the virtual base class. They don't concern us.
my $sclass;
do {
$sclass = pop @super_classes;
Carp::Assert::assert( defined $sclass ) if DEBUG;
} until $sclass eq $vclass;
my @missing = ();
{
no strict 'refs';
METHOD: foreach my $meth (@vmeths) {
CLASS: foreach my $class (@super_classes) {
next METHOD if defined &{$class.'::'.$meth};
}
push @missing, $meth;
}
}
return @missing;
}
=pod
=back
=head1 CAVEATS and BUGS
Autoloaded methods are currently not recognized. I have no idea
how to solve this.
=head1 AUTHOR
Michael G Schwern E<lt>schwern@pobox.comE<gt>
=head1 LEGAL
Copyright 2000-2015 Michael G Schwern
This program is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
See L<http://dev.perl.org/licenses/>
=head1 SEE ALSO
L<Class::Virtually::Abstract>
=cut
return "Club sandwich";
|