Storage/Handler/File.pm

package Data::Storage::Handler::File;

use strict;
use warnings;

require Exporter;
our @ISA = qw( Exporter );
our @EXPORT_OK = qw( 
  s2f
  a2f
);

sub s2f {
  my $filename = shift;
  my $string = shift;
  open(FH, '>' . $filename);
  print FH $string;
  print FH "\n";
  close(FH);
}

sub f2s {
  my $filename = shift;
  # read file at once (be careful with big files!!!)
  open(FH, '<' . $filename);
  my @buf_arr = <FH>;
  my $buf = join("", @buf_arr);
  close(FH);
  return $buf;
}

sub a2f {
  my $filename = shift;
  my $string = shift;
  open(FH, '>>' . $filename);
  #print FH "\n";
  print FH $string;
  print FH "\n";
  close(FH);
}

sub ris {
  my $string = shift;
  my $rules = shift;

  our $ris_result = 1;

  if (ref $rules eq 'HASH') {
    my @re_find = keys %{$rules};
    # replace all keys with substitutes from hash "%re_table"
    foreach my $find (@re_find) {
      my $replace = $rules->{$find};
      $ris_result &= ($string =~ s/$find/$replace/g);
    }
  }
  
  if (ref $rules eq 'ARRAY') {
    foreach my $rule (@{$rules}) {
      my $find    = $rule->[0];
      my $replace = $rule->[1];
      $ris_result &= ($string =~ s/$find/$replace/g);
    }
  }
  
  return $string;
}

sub rif {
  my $filename = shift;
  my $rules = shift;
  my $out_suffix = shift;

  my $outfile = $filename;
  $outfile .= '.' . $out_suffix if ($out_suffix);

  my $buf = f2s($filename);
  $buf = ris($buf, $rules);
  s2f($outfile, $buf);
}

sub findKeyEntries {
  my $string = shift;
  my $pattern = shift;
  my @arr = split("\n", $string);
  my @entries;
  foreach (@arr) {
    chomp;
    #print "l: ", $_, "\n";
    if (m/$pattern/) {
      push @entries, $1;
    }
  }
  return \@entries;
}

# ---------------------------------
# is a context-entry in a file?
# a "context-entry" is an entry identified 
# by a certain keystring, which itself 
# is detected dynamically
sub isEntryInFile {

  my $chk = shift;
  my $content_current = f2s($chk->{filename});
  
  # try to find all key-entries via patterns which are "entry-identifiers"
  if (my @keys = @{ findKeyEntries($chk->{'out'}, $chk->{'pattern'}{'EntryIdent'}) }) {
    # iterate through all "entry-identifiers"
    foreach (@keys) {
      my $pattern = $chk->{'pattern'}{'EntryCheck'};
      $pattern =~ s/\@\@KEY\@\@/$_/;
      my $bool_AlreadyThere = ($content_current =~ m/$pattern/);
      if ($bool_AlreadyThere) {
        $chk->{'EntryFound'} = $_;
        return 1;
      }
    }
  }

}

1;
1	joko	1.1	package Data::Storage::Handler::File;
2
3			use strict;
4			use warnings;
5
6			require Exporter;
7			our @ISA = qw( Exporter );
8			our @EXPORT_OK = qw(
9			s2f
10			a2f
11			);
12
13			sub s2f {
14			my $filename = shift;
15			my $string = shift;
16			open(FH, '>' . $filename);
17			print FH $string;
18			print FH "\n";
19			close(FH);
20			}
21
22			sub f2s {
23			my $filename = shift;
24			# read file at once (be careful with big files!!!)
25			open(FH, '<' . $filename);
26			my @buf_arr = <FH>;
27			my $buf = join("", @buf_arr);
28			close(FH);
29			return $buf;
30			}
31
32			sub a2f {
33			my $filename = shift;
34			my $string = shift;
35			open(FH, '>>' . $filename);
36			#print FH "\n";
37			print FH $string;
38			print FH "\n";
39			close(FH);
40			}
41
42			sub ris {
43			my $string = shift;
44			my $rules = shift;
45
46			our $ris_result = 1;
47
48			if (ref $rules eq 'HASH') {
49			my @re_find = keys %{$rules};
50			# replace all keys with substitutes from hash "%re_table"
51			foreach my $find (@re_find) {
52			my $replace = $rules->{$find};
53			$ris_result &= ($string =~ s/$find/$replace/g);
54			}
55			}
56
57			if (ref $rules eq 'ARRAY') {
58			foreach my $rule (@{$rules}) {
59			my $find = $rule->[0];
60			my $replace = $rule->[1];
61			$ris_result &= ($string =~ s/$find/$replace/g);
62			}
63			}
64
65			return $string;
66			}
67
68			sub rif {
69			my $filename = shift;
70			my $rules = shift;
71			my $out_suffix = shift;
72
73			my $outfile = $filename;
74			$outfile .= '.' . $out_suffix if ($out_suffix);
75
76			my $buf = f2s($filename);
77			$buf = ris($buf, $rules);
78			s2f($outfile, $buf);
79			}
80
81			sub findKeyEntries {
82			my $string = shift;
83			my $pattern = shift;
84			my @arr = split("\n", $string);
85			my @entries;
86			foreach (@arr) {
87			chomp;
88			#print "l: ", $_, "\n";
89			if (m/$pattern/) {
90			push @entries, $1;
91			}
92			}
93			return \@entries;
94			}
95
96			# ---------------------------------
97			# is a context-entry in a file?
98			# a "context-entry" is an entry identified
99			# by a certain keystring, which itself
100			# is detected dynamically
101			sub isEntryInFile {
102
103			my $chk = shift;
104			my $content_current = f2s($chk->{filename});
105
106			# try to find all key-entries via patterns which are "entry-identifiers"
107			if (my @keys = @{ findKeyEntries($chk->{'out'}, $chk->{'pattern'}{'EntryIdent'}) }) {
108			# iterate through all "entry-identifiers"
109			foreach (@keys) {
110			my $pattern = $chk->{'pattern'}{'EntryCheck'};
111			$pattern =~ s/\@\@KEY\@\@/$_/;
112			my $bool_AlreadyThere = ($content_current =~ m/$pattern/);
113			if ($bool_AlreadyThere) {
114			$chk->{'EntryFound'} = $_;
115			return 1;
116			}
117			}
118			}
119
120			}
121
122			1;
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26