--- nfo/perl/libs/Data/Rap/Metadata.pm	2003/02/18 15:35:49	1.1
+++ nfo/perl/libs/Data/Rap/Metadata.pm	2004/06/20 23:00:23	1.5
@@ -1,7 +1,21 @@
 ## ----------------------------------------------------------------------
-##  $Id: Metadata.pm,v 1.1 2003/02/18 15:35:49 joko Exp $
+##  $Id: Metadata.pm,v 1.5 2004/06/20 23:00:23 joko Exp $
 ## ----------------------------------------------------------------------
 ##  $Log: Metadata.pm,v $
+##  Revision 1.5  2004/06/20 23:00:23  joko
+##  minor fix: now creates cache-file in same directory where rap.xml is
+##
+##  Revision 1.4  2004/06/20 16:12:24  joko
+##  + sub indexTargets
+##  modified getTargetDetails to use cached target details
+##
+##  Revision 1.3  2003/03/29 07:13:19  joko
+##  better exception handling if target was not found in xml
+##
+##  Revision 1.2  2003/02/20 20:04:35  joko
+##  renamed methods
+##  - refactored xml-specific code to Data::Storage::Handler::XML
+##
 ##  Revision 1.1  2003/02/18 15:35:49  joko
 ##  + initial commit
 ##
@@ -15,102 +29,132 @@
 
 
 use Data::Dumper;
-use XML::Parser;
-use XML::Parser::EasyTree;
-use XML::XPath;
-#$XML::Parser::Easytree::Noempty=0;
-#use XML::Simple;
+use DesignPattern::Object;
+use Storable;
+use File::Basename qw( dirname );
 
 
-sub getTargetMetadata {
+sub accessMetadata {
   my $self = shift;
-  my $target = shift;
-  #my $result = $self->queryXml("*/target[\@name=\"$target\"]", keyattr => [qw( name )], forcearray => 1);
-  my $keyattr = {
-    topic => 'name',
-    taskdef => 'name',
-    target => 'name',
-  };
-  #my $result = $self->queryXml("*/target[\@name=\"$target\"]", keyattr => $keyattr, forcearray => 1);
-  $self->queryXml("*/target[\@name=\"$target\"]");
-  #return $self->_queryXml($self->{filename}, "target");
-  #print Dumper($result);
-  #return $result->{target};
-  #return $result->{target}->{$target};
-  #return $result;
-  $self->xml2easytree();
-  return $self->{payload};
+
+  # create instance of storage object once
+  if (!$self->{__rap}->{metadbengine}) {
+    $self->{__rap}->{metadbengine} = 
+      DesignPattern::Object->fromPackage('Data::Storage::Handler::XML', filename => $self->{__rap}->{filename} );
+  }
+  
+  return $self->{__rap}->{metadbengine};
+
 }
 
-sub readXmlOverview {
+sub getTargetList {
   my $self = shift;
 
-  $self->log( "Reading Job Database from XML.", 'notice' );
-
-  #$self->{payload} = XMLin($self->{filename});
-  #my $result = $self->queryXml("*/target", forcearray => 1);
-  #my $result = $self->queryXml("*/target", keyattr =>[]);
-  $self->queryXml("*/target", keyattr => [qw( name )] );
-  $self->xml2simplehash();
-  #return $result;
-  
-}
+  $self->log( "Reading database of targets (dot) from XML.", 'notice' );
 
-  sub queryXml {
-    my $self = shift;
-    my $xpq = shift;
-    my $options = shift;
+  # prepare access to metadata (assure instantiated storage handle)
+  my $mdbe = $self->accessMetadata();
 
-    $self->log( "_queryXml( xpq='$xpq' ) ", 'info' );
+  $mdbe->sendQuery("*/target");
+  $mdbe->circumflex('result');  
 
-    my $file = $self->{filename};
-    
-    if (! -e $file) {
-      $self->log("file not found: '$file'", 'error');
+  # checks  
+    if ($mdbe->isEmpty) {
+      $self->log("XML metadata was empty.", 'critical');
       return;
     }
+  
+  # trace
+    #print Dumper($self->{buffer});
+    #exit;
+
+  # behaviour
+    #$self->xml2simplehash();
+    my $tree = $mdbe->toEasyTree();
+  #return $result;
+  
+  # trace
+    #print Dumper($tree);
+    #exit;
+  
+  # build result
+    my @targets;
+    foreach my $entry (@{$tree->{content}}) {
+      my $description = $entry->{content}->[0]->{content}->[0]->{content};
+      push @targets, { name => $entry->{attrib}->{name}, description => $description };
+    }
 
-    #print "file: $file", "\n";
-    #print "xpq: $xpq", "\n";
-    
-    # filter nodes by xpath-query
-      my $xp = XML::XPath->new( filename => $file );
-      my $nodeset = $xp->find($xpq);
-    
-    # build result xml
-      my $buffer;
-      foreach my $node ($nodeset->get_nodelist) {
-        $buffer .= XML::XPath::XMLParser::as_string($node) . "\n\n";
-      }
-      #$buffer .= '';
-      #$buffer = "<result>$buffer</result>";
-    
-    # trace
-      #print $buffer, "\n";
-
-    $self->{buffer} = $buffer;
-    
-  }
+  return \@targets;
+  
+}
 
 
-sub xml2easytree {
+sub getTargetDetails {
   my $self = shift;
-    # convert xml data to native perl data structure
-      my $parser = XML::Parser->new( Style => 'EasyTree', Handlers => { Char => sub {} } );
-      my $data = $parser->parse($self->{buffer});
-
-    my $hash = $data->[0];
-    
-    # trace
-      #print Dumper($hash);
-      #exit;
-
-    $self->{payload} = $hash;
+  my $target = shift;
+  my $options = shift;
+  
+  # check cache and return result from there
+  if (my $result = $self->{cache}->{targets}->{$target} and not $options->{force}) {
+    return $result;
+  }
+  
+  # get metadata for single task from storage
+  my $mdbe = $self->accessMetadata();
+  $mdbe->sendQuery("*/target[\@name=\"$target\"]");
+  
+  # FIXME: this is wrong behaviour! upper statement should return a proper
+  # result, which itself (already) has the method 'isEmpty' or similar...
+  if ($mdbe->isEmpty()) {
+    $self->log( "Target '$target' not found.", 'notice' );
+    return;
+  }
+  
+  my $tree = $mdbe->toEasyTree();
+  
+  # trace
+  #print Dumper($tree);
+  #exit;
+  
+  return $tree;
 }
 
-sub xml2simplehash {
+sub indexTargets {
   my $self = shift;
-  $self->{payload} = XMLin($self->{buffer});
+  my $options = shift;
+  
+  # determine filename for cache-file
+  my $filename = 'rap.xml.cache';
+  if (my $rapfile = $self->{__rap}->{filename}) {
+    if (my $path = dirname($rapfile)) {
+      $filename = $path . '/' . $filename;
+    }
+  }
+  
+  if ($options->{build}) {
+    $self->log("Building index of Targets", 'notice');
+    # clear cache
+    delete $self->{cache}->{targets};
+    my $list = $self->getTargetList();
+    foreach my $target (@$list) {
+      $self->log("Reading target: $target->{name}", 'info');
+      my $details = $self->getTargetDetails($target->{name}, { force => 1 });
+      $self->{cache}->{targets}->{$target->{name}} = $details;
+    }
+    store $self->{cache}->{targets}, $filename;
+    
+  } elsif ($options->{load}) {
+    if (not -e $filename) {
+      return;
+    }
+    if ($self->{cache}->{targets} = retrieve($filename)) {
+      return 1;
+    }
+  
+  } else {
+    $self->log("Please call with options build or load", 'warning');
+  
+  }
 }
 
 1;