| #******************************************************************************* |
| #* Copyright (c) 2011 Forschungszentrum Juelich GmbH. |
| #* All rights reserved. This program and the accompanying materials |
| #* are made available under the terms of the Eclipse Public License v1.0 |
| #* which accompanies this distribution, and is available at |
| #* http://www.eclipse.org/legal/epl-v10.html |
| #* |
| #* Contributors: |
| #* Wolfgang Frings (Forschungszentrum Juelich GmbH) |
| #*******************************************************************************/ |
| package LML_gen_nodedisplay; |
| my($debug)=0; |
| use strict; |
| use Time::Local; |
| use Time::HiRes qw ( time ); |
| use Data::Dumper; |
| |
| |
| ################################################################################################################ |
| # job insertion |
| ################################################################################################################ |
| sub insert_job_into_nodedisplay { |
| my($self) = shift; |
| my($schemeref) = shift; |
| my($dataref) = shift; |
| my($nodelist) = shift; |
| my($oid) = shift; |
| my($data,$node,$listref,@nodelistrefs,@nodelistrefs_reduced, $allcovered, $child); |
| |
| foreach $node (sort(split(/\s*,\s*/,$nodelist))) { |
| $listref=$self->get_numbers_from_name($node,$schemeref); |
| push(@nodelistrefs,$listref); |
| } |
| |
| foreach $listref (@nodelistrefs) { |
| print "insert_job_into_nodedisplay, before: ",join(',',@{$listref}),"\n" if($debug>=2); |
| } |
| |
| # for each system part |
| foreach $child (@{$schemeref->{_childs}}) { |
| $allcovered=$self->_reduce_nodelist($child,\@nodelistrefs,\@nodelistrefs_reduced); |
| } |
| |
| print "insert_job_into_nodedisplay, allcovered=$allcovered\n" if($debug>=2); |
| |
| foreach $listref (@nodelistrefs_reduced) { |
| $self->_insert_jobnode_nodedisplay($dataref,$listref,$oid); |
| } |
| |
| |
| return(1); |
| } |
| |
| sub _insert_jobnode_nodedisplay { |
| my($self) = shift; |
| my($dataref)=shift; |
| my($nodelistref)=shift; |
| my($oid) = shift; |
| my($myspec,$min,$max,$subspec,$child); |
| my($lmin,$lmax,$subchilds); |
| my $level=$dataref->{_level}; |
| my $xspace=" "x$level; |
| my (@covered, @childlist, $newchild, @newlist, $isleaf, $i, @notcoveredlist, $newlist, $updatechild); |
| |
| print "_insert_jobnode_nodedisplay: $xspace # START level=$level nodelistref=>",join(',',@{$nodelistref}),"<\n" if($debug>=2); |
| |
| $myspec=$nodelistref->[0]; |
| if($myspec=~/^\((.*)\)$/) { |
| my $list=$1; |
| for $subspec (split(',',$list)) { |
| my @list = @{$nodelistref}; |
| $list[0]=$subspec; |
| print "_insert_jobnode_nodedisplay: $xspace -> re-calling with top subspec >$subspec<\n" if($debug>=2); |
| $self->_insert_jobnode_nodedisplay($dataref,\@list, $oid); |
| } |
| print "_insert_jobnode_nodedisplay: $xspace # END level=$level nodelistref=>",join(',',@{$nodelistref}),"<\n" if($debug>=2); |
| return(); |
| } elsif($myspec=~/(\d+)\-(\d+)/) { |
| $min=$1;$max=$2; |
| } else { |
| $min=$max=$myspec; |
| } |
| for($i=$min;$i<=$max;$i++) {$covered[$i]=1;} |
| |
| @newlist = @{$nodelistref};shift(@newlist); |
| $isleaf=($#newlist == -1)?1:0; |
| # scan child |
| @childlist=@{$dataref->{_childs}}; |
| foreach $child (@childlist) { |
| $lmin=$child->{ATTR}->{min}; |
| $lmax=$child->{ATTR}->{max}; |
| $subchilds=$#{$child->{_childs}}+1; |
| print "_insert_jobnode_nodedisplay: $xspace ==> level=$level [$min..$max] found child: ($lmin..$lmax) #subchilds=$subchilds\n" if($debug>=2); |
| |
| if(($max<$lmin) || ($min>$lmax)) { |
| print "_insert_jobnode_nodedisplay: $xspace -> child full outside range, skip\n" if($debug>=2); |
| next; |
| } |
| # case 2: full covered |
| if(($min>=$lmin) && ($max<=$lmax)) { |
| print "_insert_jobnode_nodedisplay: $xspace -> child full covered, isleaf=$isleaf\n" if($debug>=2); |
| |
| if( ($min==$lmin) && ($max==$lmax) ) { # exact match |
| $updatechild=$child; |
| } else { |
| if($min>$lmin) { # overlap before |
| print "_insert_jobnode_nodedisplay: $xspace -> duplicate child with (",($lmin),"..",($min-1),"), inserting subnodes ...\n" if($debug>=2); |
| $newchild=$dataref->duplicate_child($child); |
| $newchild->{ATTR}->{min}=$lmin; |
| $newchild->{ATTR}->{max}=$min-1; |
| print "_insert_jobnode_nodedisplay: $xspace -> adjust min of child to (",$min,"..",($lmax),")\n" if($debug>=2); |
| $child->{ATTR}->{min}=$min; |
| } |
| if($max<$lmax) { # overlap after, copy tree |
| print "_insert_jobnode_nodedisplay: $xspace -> duplicate child with (",($max+1),"..",($max),")\n" if($debug>=2); |
| $newchild=$dataref->duplicate_child($child); |
| $newchild->{ATTR}->{min}=$max+1; |
| $newchild->{ATTR}->{max}=$lmax; |
| print "_insert_jobnode_nodedisplay: $xspace -> adjust max of child to (",$min,"..",($max),")\n" if($debug>=2); |
| $child->{ATTR}->{max}=$max; |
| } |
| $updatechild=$child; |
| } |
| |
| if($isleaf) { |
| # insert new child |
| print "_insert_jobnode_nodedisplay: $xspace remove old child\n" if($debug>=2); |
| $dataref->remove_child($updatechild); |
| print "_insert_jobnode_nodedisplay: $xspace -> add new child with (",($min),"..",($max),")\n" if($debug>=2); |
| $updatechild=$dataref->new_child(); |
| $updatechild->add_attr({ oid => $oid, min => $min, max => $max }); |
| } else { |
| # change tree of existing child |
| # $updatechild->{ATTR}->{min}=$min; |
| # $updatechild->{ATTR}->{max}=$max; |
| print "_insert_jobnode_nodedisplay: $xspace -> duplicate child with (",($min),"..",($max),"), inserting subnodes ...\n" if($debug>=2); |
| $self->_insert_jobnode_nodedisplay($updatechild,\@newlist, $oid) ; |
| } |
| for($i=$min;$i<=$max;$i++) {$covered[$i]=0} |
| |
| } elsif(($min<$lmin) && ($max<=$lmax)) { |
| print "_insert_jobnode_nodedisplay: $xspace -> child not full covered: low overlap #subchilds=$subchilds\n" if($debug>=2); |
| |
| if($max<$lmax) { # overlap high |
| $newchild=$dataref->duplicate_child($child); |
| $newchild->{ATTR}->{min}=$max+1; |
| $newchild->{ATTR}->{max}=$lmax; |
| print "_insert_jobnode_nodedisplay: $xspace -> duplicate child with (",($max+1),"..",($lmax),")\n" if($debug>=2); |
| } |
| if($isleaf) { |
| $dataref->remove_child($child); # replace subtree |
| print "_insert_jobnode_nodedisplay: $xspace remove old child\n" if($debug>=2); |
| $newchild=$dataref->new_child(); |
| $newchild->add_attr({ oid => $oid, min => $lmin, max => $max }); |
| print "_insert_jobnode_nodedisplay: $xspace -> insert new child with (",($lmin),"..",($max),")\n" if($debug>=2); |
| } else { |
| $child->{ATTR}->{min}=$lmin; |
| $child->{ATTR}->{max}=$max; |
| print "_insert_jobnode_nodedisplay: $xspace -> adjust range with (",($lmin),"..",($max),"), inserting subnodes ...\n" if($debug>=2); |
| $self->_insert_jobnode_nodedisplay($child,\@newlist, $oid) ; |
| } |
| for($i=$min;$i<=$lmin;$i++) {$covered[$i]=0} |
| } elsif(($min>=$lmin) && ($max>$lmax)) { |
| print "_insert_jobnode_nodedisplay: $xspace -> child not full covered: high overlap #subchilds=$subchilds\n" if($debug>=2); |
| if($min>$lmin) { # overlap low |
| $newchild=$dataref->duplicate_child($child); |
| $newchild->{ATTR}->{min}=$lmin; |
| $newchild->{ATTR}->{max}=$min-1; |
| print "_insert_jobnode_nodedisplay: $xspace -> duplicate child with (",($lmin),"..",($min-1),")\n" if($debug>=2); |
| } |
| if($isleaf) { |
| $dataref->remove_child($child); # replace subtree |
| print "_insert_jobnode_nodedisplay: $xspace remove old child\n" if($debug>=2); |
| $newchild=$dataref->new_child(); |
| $newchild->add_attr({ oid => $oid, min => $min, max => $lmax }); |
| print "_insert_jobnode_nodedisplay: $xspace -> insert new child with (",($min),"..",($lmax),")\n" if($debug>=2); |
| } else { |
| $child->{ATTR}->{min}=$min; |
| $child->{ATTR}->{max}=$lmax; |
| print "_insert_jobnode_nodedisplay: $xspace -> adjust range with (",($min),"..",($lmax),"), inserting subnodes ...\n" if($debug>=2); |
| $self->_insert_jobnode_nodedisplay($child,\@newlist, $oid) ; |
| } |
| for($i=$min;$i<=$lmax;$i++) {$covered[$i]=0} |
| } |
| } |
| |
| # build entries for not already covered childs |
| for($i=$min;$i<=$max;$i++) { |
| push(@notcoveredlist,$i) if($covered[$i]==1); |
| } |
| if(@notcoveredlist) { |
| $newlist=reduce_list(@notcoveredlist);$newlist=~s/\(//gs;$newlist=~s/\)//gs; |
| print "_insert_jobnode_nodedisplay: $xspace -> notcoveredlist= >$newlist<\n" if($debug>=2); |
| for $subspec (split(',',$newlist)) { |
| if($subspec=~/(\d+)\-(\d+)/) {$min=$1;$max=$2; } |
| else {$min=$max=$subspec;} |
| } |
| $newchild=$dataref->new_child(); |
| if($isleaf) { |
| print "_insert_jobnode_nodedisplay: $xspace -> insert new child with (",($min),"..",($max),")\n" if($debug>=2); |
| $newchild->add_attr({ oid => $oid, min => $min, max => $max }); |
| } else { |
| $newchild->add_attr({ min => $min, max => $max, oid => $dataref->{ATTR}->{oid} }); |
| print "_insert_jobnode_nodedisplay: $xspace -> insert new child with (",($min),"..",($max),"), inserting subnodes ...\n" if($debug>=2); |
| $self->_insert_jobnode_nodedisplay($newchild,\@newlist, $oid) ; |
| } |
| |
| } |
| |
| print "_insert_jobnode_nodedisplay: $xspace # END level=$level nodelistref=>",join(',',@{$nodelistref}),"<\n" if($debug>=2); |
| |
| } |
| |
| |
| sub _reduce_nodelist { |
| my($self) = shift; |
| my($schemeref)=shift; |
| my($nodelistrefs)=shift; |
| my($newnodelistrefs)=shift; |
| my($rg,$child, $listref, @covered, $allcovered, $nodenum,@shortlists,@newshortlists, $lastfound); |
| my $level=$schemeref->{_level}; |
| my $xspace=" "x$level; |
| |
| |
| print "_reduce_nodelist: $xspace # START level=$level scheme min..max=$schemeref->{ATTR}->{min}..$schemeref->{ATTR}->{max}\n" if($debug>=2); |
| for($nodenum=$schemeref->{ATTR}->{min};$nodenum<=$schemeref->{ATTR}->{max};$nodenum++) { |
| $covered[$nodenum]=0; |
| } |
| |
| # check which treenodes are given in nodelist, covered = {0 no nodes, 1 all nodes, 2 some nodes} |
| foreach $listref (@{$nodelistrefs}) { |
| $nodenum=$listref->[0]; |
| # check only nodes which are described by this subtree of the scheme |
| next if($nodenum<$schemeref->{ATTR}->{min}); |
| next if($nodenum>$schemeref->{ATTR}->{max}); |
| print "_reduce_nodelist: $xspace # CHECK nodenum=$nodenum\n" if($debug>=2); |
| if($#{$listref}==0) { |
| # node full covered |
| $covered[$nodenum]=1; |
| } else { |
| my(@list); |
| $covered[$nodenum]=2 if($covered[$nodenum]==0); |
| # remove top elem and add it to sublist |
| @list=@{$listref};shift(@list);push(@{$shortlists[$nodenum]},\@list); |
| } |
| } |
| |
| # check childs of all nodes which are not fully covered |
| $allcovered=1; |
| for($nodenum=$schemeref->{ATTR}->{min};$nodenum<=$schemeref->{ATTR}->{max};$nodenum++) { |
| if($covered[$nodenum]==2) { |
| my $allcovered_=1; |
| foreach $child (@{$schemeref->{_childs}}) { |
| my(@newlist,$allcovered__); |
| $allcovered__=$self->_reduce_nodelist($child,$shortlists[$nodenum],\@newlist); |
| $allcovered_=0 if(!$allcovered__); |
| push(@{$newshortlists[$nodenum]},@newlist); |
| } |
| # reduce if all covered |
| if($allcovered_) { |
| $covered[$nodenum]=1; |
| $newshortlists[$nodenum]=[]; |
| } else { |
| $allcovered=0; |
| } |
| |
| } elsif($covered[$nodenum]==0) { |
| $allcovered=0; |
| } |
| } |
| |
| # build new node list |
| if($allcovered) { |
| push(@{$newnodelistrefs},[$schemeref->{ATTR}->{min}."-".$schemeref->{ATTR}->{max}]); |
| |
| } else { |
| # build list of allcovered subnodes |
| my(@nlist,$newlist); |
| for($nodenum=$schemeref->{ATTR}->{min};$nodenum<=$schemeref->{ATTR}->{max};$nodenum++) { |
| push(@nlist, $nodenum) if($covered[$nodenum]==1); |
| } |
| if(@nlist) { |
| $newlist=reduce_list(@nlist); |
| push(@{$newnodelistrefs},[$newlist]); |
| } |
| |
| |
| # build list of partly covered nodes |
| for($nodenum=$schemeref->{ATTR}->{min};$nodenum<=$schemeref->{ATTR}->{max};$nodenum++) { |
| if($covered[$nodenum]==2) { |
| my(@nlist,$newlist,$nd); |
| for($nd=$nodenum;$nd<=$schemeref->{ATTR}->{max};$nd++) { |
| if($covered[$nd]==2) { |
| if(&twolist_compare($newshortlists[$nodenum],$newshortlists[$nd])) { |
| push(@nlist,$nd); |
| $covered[$nd]=-1; |
| } |
| } |
| } |
| $newlist=reduce_list(@nlist); |
| |
| foreach $listref (@{$newshortlists[$nodenum]}) { |
| unshift(@$listref, $newlist ); |
| push(@{$newnodelistrefs},$listref); |
| } |
| } |
| } |
| |
| } |
| |
| return($allcovered); |
| } |
| |
| sub twolist_compare { |
| my($listref1) = shift; |
| my($listref2) = shift; |
| my($l1,$l2, $rc); |
| |
| $rc=1; |
| # print "Compare1:", Dumper($listref1),"\n"; |
| # print "Compare2:", Dumper($listref2),"\n"; |
| if($#{$listref1} ne $#{$listref2}) { |
| return(0); |
| } |
| for($l1=0;$l1<=$#{$listref1};$l1++) { |
| if($#{$listref1->[$l1]} ne $#{$listref2->[$l1]}) { |
| return(0); |
| } |
| for($l2=0;$l2<=$#{$listref1->[$l1]};$l2++) { |
| $rc=0 if($listref1->[$l1]->[$l2] ne $listref2->[$l1]->[$l2]); |
| } |
| } |
| return($rc); |
| } |
| |
| sub reduce_list { |
| my(@list) = @_; |
| my(@newlist,$i,$start,$lastfound); |
| |
| return("") if(!@list); |
| $lastfound=$list[0]; |
| $start=$list[0]; |
| for($i=1;$i<=$#list;$i++) { |
| if(($list[$i]-1) == $lastfound) { |
| $lastfound++; |
| } else { |
| if($start != $lastfound) {push(@newlist, $start."-".$lastfound)} |
| else {push(@newlist, $start)}; |
| $lastfound=$list[$i]; |
| $start=$lastfound; |
| } |
| } |
| if($start != $lastfound) {push(@newlist, $start."-".$lastfound)} |
| else {push(@newlist, $start)}; |
| |
| if($#newlist>0) { |
| return("(" . (join(',',@newlist)) .")"); |
| } else { |
| return($newlist[0]); |
| } |
| } |
| |
| |
| |
| ################################################################################################################ |
| # help function |
| ################################################################################################################ |
| sub get_numbers_from_name { |
| my($self) = shift; |
| my($name) = shift; |
| my($schemeref) = shift; |
| my($id,$listref,$format,$child); |
| |
| foreach $child (@{$schemeref->{_childs}}) { |
| $listref=$self->_get_numbers_from_name($child,$name); |
| } |
| |
| return($listref); |
| } |
| |
| sub _get_numbers_from_name { |
| my($self) = shift; |
| my($schemeref)=shift; |
| my($name)=shift; |
| my($rg,$child,@list,$listref); |
| |
| |
| $rg=$schemeref->{ATTR}->{_maskregall}; |
| if($name=~/^$rg$/) { |
| @list=$name=~/^$rg$/; |
| print "get_numbers_from_name: found on level ",$schemeref->{_level}+1," $name -> ",join(',',@list),"\n" if($debug>=2); |
| return(\@list); |
| } else { |
| foreach $child (@{$schemeref->{_childs}}) { |
| $listref=$self->_get_numbers_from_name($child,$name); |
| if(defined($listref)) { |
| return($listref); |
| } |
| } |
| } |
| return(undef); |
| } |
| |
| |
| 1; |
