Suche Tie-Hash Modul um Flachen Hash in einen Baum zu wandeln (Allgemeines zu Perl)

[thread]15525[/thread]

Suche Tie-Hash Modul um Flachen Hash in einen Baum zu wandeln

Leser: 19

Articles: hide open all | hide show old branches

+6 replies

topeg

2010-10-12 17:30

User since
2006-07-10
2611 Artikel
BenutzerIn

user image

Ich suche eine Tie-Modul dass eine flache Struktur wie:

Code: (dl )

{
  'c.a' => 'D',
  'a.a.a' => 'A',
  'b' => 'C',
  'a.a.b' => 'B',
  'c.b' => 'E',
}

virtuell in einen Hash-Baum umwandelt Ungefähr so:

Code: (dl )

{
  a => {
         a => {
                a => 'A',
                b => 'B',
              },
       },
  c => {
         b => 'E',
         a => 'D',
       },
  b => 'C',
}

Kann mir jemand suchen helfen? :-)
Wenn keinem etwas einfällt, werde ich es wohl selber schreiben müssen.

+5 replies

2010-10-12 17:57

User since
2003-08-04
12208 Artikel
Admin1

kenne kein modul, aber der code ist ziemlich simpel:

Code (perl): (dl )

my $new = {};
tree($new, $_, $hash{$_}) for keys %hash;

sub tree {
    my ($target, $key, $val) = @_;
    my ($char, $rest) = split /\./, $key, 2;
    unless (defined $rest) {
        $target->{$char} = $val;
        return;
    }
    $target->{$char} ||= {};
    tree($target->{$char}, $rest, $val);
}

Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live. -- Damian Conway in "Perl Best Practices"
lesen: Wiki:

Wie frage ich & perlintro Wiki:

brian's Leitfaden für jedes Perl-Problem

+4 replies

topeg

2010-10-12 18:25

User since
2006-07-10
2611 Artikel
BenutzerIn

user image

Ich weiß das das transformieren nicht kompliziert ist, so mache ich ja bisher (nur nicht rekursiv das gibt "deep recursion" Warungen).
Aber das Script braucht zum starten zu lange, und verbraucht meist mehr als 3Gb RAM. Viel Overhead entsteht durch die tief verschachtelte aber spärlich besetzte Struktur. Da es meist nur um den Zugriff auf ein paar 1000 Einträge geht, ist das etwas unproportional. Entweder ich schreibe alles um, oder ich versuche das Puffern und dynamische Parsen in Hashes mit Tie zu verstecken. Das würde mir viel Arbeit ersparen.
Für das Lesen und Cachen habe ich schon ein Tie Modul gefunden. Mir fehlt nur noch das Umwandeln.

+2 replies

2010-10-12 18:34

User since
2003-08-04
12208 Artikel
Admin1

wie genau willst du denn drauf zugreifen und was möchtest du als rückgabe?

Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live. -- Damian Conway in "Perl Best Practices"
lesen: Wiki:

Wie frage ich & perlintro Wiki:

brian's Leitfaden für jedes Perl-Problem

topeg

2010-10-12 20:28

User since
2006-07-10
2611 Artikel
BenutzerIn

user image

Mal ein paar vereinfachte Beispiele:

Code (perl): (dl )

sub get_element_by_name($$)
{
  my ($conf,$name)=@_;
  return undef unless(is_valid($conf,'name',$name));
  my $system=$conf->{system};
  my $data=$conf->{data}->{$system};

  return $data->{elements}->{$name}
}

sub get_element_namespace($$)
{
  my ($conf,$element)=@_;
  return undef unless(is_valid($conf,'element',$element));
  my $system=$conf->{system};
  my $data=$conf->{data}->{$system};

  return $data->{namespaces}->{$element->{namespace}};
}

sub get_namespace_default($$)
{
  my ($conf,$namespace)=@_;
  return undef unless(is_valid($conf,'namespace',$namespace));
  my $system=$conf->{system};
  my $data=$conf->{data}->{$system};

  my $default=$data->{default};
  my $name=$data->{namespaces}->{$namespace}->{$default};
  return $data->{elements}->{$name};
}

Ähnlich sieht es beim setzen von Werten aus, nur dass an verschiedenen Stellen noch nach bestimmten Werten geprüft wird.

weiterhin hat "namespace" so Einträge wie

Code (perl): (dl )

$namespace->{alternative}->{namespaces}->{'namespacex'}->{systems}->{'systemy'}->{name}

oder

Code (perl): (dl )

$element->{description}->{lang}->{'de'}->{encoding}->{defalult}->{fallback}->{type}->{'UTF'}->{subtype}='8';

auch ganz nett:

Code (perl): (dl )

my $fs=$system->{$element->{system}}->{filesystem};
my $sep=$fs->{separator};
my $dname=$fs->{data}->{file}->{name};
my $dfile=$fs->{file}->{$dname}->{absolue}->{path}->{separator}->{$sep}
$dfile=$fs->{file}->{$dname}->{is}->{linked}->{to}->{file}->{absolute}->{path}->{separator}->{$sep} if($fs->{file}->{$dname}->{is}->{linked}->{to}->{file}->{absolute}->{path}->{separator}->{$sep});

und da Fehlt noch die abfrage von relativen Pfaden und von wo ein relativer Pfad gesetzt ist, etc.

in der Datei steht dann so was wie:

Code: (dl )

system SystemX filesystem file Daten1 is linked to file absolute path separator / = mounts/mounta/data.dat

Edit:
Was ich will ist ein anderes Dateiformat und ein anderes Script. :-/
Was ich als Rückgaben möchte sind Strings und Hashes. :-)
Last edited: 2010-10-12 20:41:10 +0200 (CEST)

topeg

2010-10-13 14:16

User since
2006-07-10
2611 Artikel
BenutzerIn

user image

Ein kurzer Bericht.

Ich den Parser umgeschrieben und konnte die Startzeit von über 10 Minuten auf ~40 Sekunden reduzieren.
für alle die es interessiert:

Code (perl): (dl )

sub load
{
  my $file=shift;
  defined($file)           or die(qq(No file defined!\n));
  -f $file                 or die(qq(ERROR: File "$file" not defined or not exists\n));
  open(my $fh, '<', $file) or die(qq(ERROR: Can't open File "$file" $!\n));
  my $ret={};
  my $lastkey;
  while(my $line=<$fh>)
  {
    chomp($line);
    next if($line=~/^\s*#/o || $line=~/^\s*$/o);
    if(my ($key,$value)=$line=~/^\s*([^=]+?)\s*=\s*(.*?)(?:#.*)?\s*$/o)
    {
      $ret->{$key}=$value // '';
      $lastkey=$key;
    }
    elsif($lastkey)
    { $ret->{$lastkey}.="\n$line"; }
  }
  close($fh);
  return $ret;
}

sub parse
{
  my $hash=shift;
  my $sep=shift // '.';

  return {} unless($hash && ref($hash) eq 'HASH');

  my $ret={};
  KEYLOOP:
  for my $k (keys(%$hash))
  {
    my $ref=\$ret;
    my @kk=();
    for my $n (split(/\Q$sep\E/,$k))
    {
      push(@kk,$n);
      $ref=\$$ref->{$n};
      next KEYLOOP if($$ref && !ref($$ref))
    }
    $$ref=$hash->{$k};
  }
  return $ret;
}

Dabei ist auch die Speicherplatzerbrauch auch etwas geschrumpft (die Daten werden nicht sieben mal im Speicher gehalten.). Jetzt muss ich nur noch verhindern, das gleich alle abhängigen Dateien geladen werden. Das macht ~90 des gesamten Speicherverbrauches aus. Da werde ich wohl mit einem Tie::File Modul arbeiten.

Meine Experimente mit Tie::Hash sind nicht sehr befriedigend. Das erzeugen einer Instanz ist um ein vielfaches langsamer als das direkte Parsen. Möglicherweise liegt es auch an der Art wie ich die Daten verwalte.

Ich werde weiter schauen.

View all threads created 2010-10-12 17:30.