CfgTie::TieGeneric - A generic hash that automatically binds others

        my %gen;
        tie %gen, 'CfgTie::TieGeneric';

#!/usr/bin/perl -w
#Copyright 1998-2001, Randall Maas.  All rights reserved.  This program is free
#software; you can redistribute it and/or modify it under the same terms as
#PERL itself.

package CfgTie::TieGeneric;
use Secure::File;
use vars qw($VERSION @ISA);
use AutoLoader 'AUTOLOAD';
$VERSION='0.41';

# These are the builtins that we always add to the global arena...

# This forms the abstract tie for the net sub-hash
my $net_builtins ={host=>['CfgTie::TieHost'],
      service=>['CfgTie::TieServ'],
      protocol=>['CfgTie::TieProto'],
      addr    =>['CfgTie::TieNet']
    };

# This forms the abstract tie for the mail sub-hash
my $mail_builtins={aliases=>['CfgTie::TieAliases']};

my $builtins =
     {
        user => ['CfgTie::TieUser'],
        group =>['CfgTie::TieGroup'],
#        env =>  \%main'ENV,
        mail => ['CfgTie::TieGeneric', $mail_builtins],
        net =>  ['CfgTie::TieGeneric', $net_builtins], 
        runlevel=>['CfgTie::TieRCService'],
     };

use CfgTie::TieGroup;
use CfgTie::TieServ;
use CfgTie::TieProto;
use CfgTie::TieNet;
use CfgTie::TieHost;
@ISA=qw(CfgTie::TieGroup CfgTie::TieServ  CfgTie::TieProto
	CfgTie::TieNet  CfgTie::TieHost AutoLoader);
1;
__END__


sub TIEHASH
{
   my ($self,$BuildIns) =@_;
   if (!defined $BuildIns) {$BuildIns = $builtins;}
   my $node = {builtins => $BuildIns};
   return bless $node, $self;
}
sub new {TIEHASH(@_);}

my $Node_Separator = '/';

sub EXISTS
{
   my ($self,$key)=@_;

   if (!defined $key) {return 0;}

   #if the $key has a separator in it, check the cache.
   if (exists $self->{Cache}->{$key})   {return 1;}

   # Check to see if it is already mapped in, and overrides ours
   if (exists $self->{Contents}->{$key}) {return 1;}

   #At this point, it is not mapped in.
   #Try to automagically add it in..
   #First try to use a builtin if possible
   if (exists $self->{builtins}->{$key}) {return 1;}

   #recursively try to find it...
   my ($LeftKey, $RightKey);
   if ($key =~ /^(.*)\/([^\/]+)$/)
     {$LeftKey=$1; $RightKey=$2;}
    else
     {
        #Finally try to mount the thingy
        eval "use $key";
        tie %{$self->{Contents}->{$key}}, $key;
	return exists $self->{Contents}->{$key};
     }
   if (!EXISTS($self, $LeftKey)) {return 0;}

   # stick it in the quick look up cache
   my $X = FETCH($self, $LeftKey);
   $self->{Cache}->{$key} = $X->{$RightKey};
   return 1;
}

sub FETCH
{
   my ($self,$key)=@_;
   if (!EXISTS($self,$key)) {return;}
   #If we fully cached the long key, get already
   if (!exists $self->{Contents}->{$key})
     {
        my ($A,$B) = @{$self->{builtins}->{$key}};

        #load the perl module
        eval "use $A";

        #Tie in the key
        tie %{$self->{Contents}->{$key}}, $A,$B;
     }
   if (exists $self->{Cache}->{$key}) {return $self->{Cache}->{$key};}
   #Try to get the local thing first
   if (exists $self->{Contents}->{$key}) {return $self->{Contents}->{$key};}
   return undef;
}

sub HTML($)
{
   my $self=shift;
   my $A='';
   for (my $I=FIRSTKEY($self); $I; $I=NEXTKEY($self,$I))
    {
       $A.="<tr>".CfgTie::Cfgfile::td("<a href=\"$I\">$I</a>")."</tr>";
    }
   CfgTie::Cfgfile::table('Directory',$A,1);
}

sub FIRSTKEY
{
   my $self = shift;
   my $a = keys %{$self->{Contents}};

   my $b = scalar each %{$self->{Contents}};
   if ($b) {return $b;}

   #Scan thru the builtins
   my $c = keys %{$self->{builtins}};
   return scalar each %{$self->{builtins}};
}

sub NEXTKEY
{
   my $self = shift;
   my $lastkey=shift;
   my $a = scalar each %{$self->{Contents}};
   if ($a) {return $a;}

   if (exists $self->{Contents}->{$lastkey})
     {
        #Prime it with a psuedo FIRSTKEY
        my $b = keys %{$self->{builtins}};
     }

   while (($a) = each %{$self->{builtins}})
    {
       if (!exists $self->{Contents}->{$a})
         {return $a;}
    }
   return $a;
}