U
s
e UNIX “f
i
lter” model
31
Having filled in all of the required data, we called 
$cust->save
to save our
new record. If the save is successful, the code attribute will have been filled in and
we can display the new customer’s code to the user by way of the 
$cust->code
attribute access method.
If, on the other hand, we wanted to access an existing customer record, we would
pass the customer to the 
Customer->new
method (e.g., 
Customer->new(id
=>
'CUS-00123')
) and the 
init
method would populate our object with the cus-
tomer’s data. We could then either use this data in some way or alternatively alter it
and use the 
save
method to write the changed record back to the database.
2.4
Use 
UNIX
“fil
t
er” model
UNIX
filter programs give us a very good example to follow when it comes to building
a number of small, reusable utilities each of which is designed to carry out one task.
2.4.1 Overview of 
t
he fil
t
er model
Many operating systems, principally 
UNIX
and its variants, support a feature called
I
/
O
redirection. This feature is also supported in Microsoft Windows, although as
it is a command line feature, it is not used as much as it is in 
UNIX
I
/
O
redirection
gives the user great flexibility over where a program gets its input and sends its
output. This is achieved by treating all program input and output as file input and
output. The operating system opens two special file handles called 
STDIN
and
STDOUT
, which, by default, are attached to the user’s keyboard and monitor.5 This
means that anything typed by the user on the keyboard appears to the program to
be read from 
STDIN
and anything that the program writes to 
STDOUT
appears on
the user’s monitor.
For example, if a user runs the 
UNIX
command
ls
then a list of files in the current directory will be written to 
STDOUT
and will appear
on the user’s monitor.
There are, however a number of special character strings that can be used to
redirect these special files. For example, if our user runs the command
ls > files.txt
then anything that would have been written to 
STDOUT
is, instead, written to the file
files.txt. Similarly, 
STDIN
can be redirected using the 
<
character. For example,
5
In practice there is also a third file handle called 
STDERR
which is a special output file to which error mes-
sages are written, but this file can be safely ignored for the purposes of this discussion.
How to rotate all pages in pdf - rotate PDF page permanently in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Users to Change the Rotation Angle of PDF File Page Using C#
how to rotate a page in pdf and save it; rotate single page in pdf reader
How to rotate all pages in pdf - VB.NET PDF Page Rotate Library: rotate PDF page permanently in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
PDF Document Page Rotation in Visual Basic .NET Class Application
how to rotate page in pdf and save; rotate all pages in pdf preview
32
CHAPTER 
General mung
i
ng pract
i
ce
s
sort < files.txt
would sort our previously created file in lexical order (since we haven’t redirected
the output, it will go to the user’s monitor).
Another, more powerful, concept is 
I
/
O
pipes. This is where the output of one
process is connected directly to the input of another. This is achieved using the 
|
character. For example, if our user runs the command
ls | sort
then anything written to the 
STDOUT
of the 
ls
command (i.e., the list of files in the
current directory) is written directly to the 
STDIN
of the 
sort
command. The 
sort
command processes the data that appears on its 
STDIN
, sorts that data, and writes
the sorted data to its 
STDOUT
. The 
STDOUT
for the 
sort
command has not been
redirected and therefore the sorted list of files appears on the user’s monitor. 
A summary of the character strings used in basic 
I
/
O
redirection is given in
table 2.1. More complex features are available in some operating systems, but the
characters listed are available in all versions of 
UNIX
and Windows.
2.4.2 Advan
t
ages of 
t
he fil
t
er model
The filter model is a very useful concept and is fundamental to the way that 
UNIX
works. It means that 
UNIX
can supply a large number of small, simple utilities, each
of which do one task and do it well. Many complex tasks can be carried out by
plugging a number of these utilities together. For example, if we needed to list all
of the files in a directory with a name containing the string “proj01” and wanted
them sorted in alphabetical order, we could use a combination of 
ls
sort
, and
grep
6 like this:
ls –1 | grep proj01 | sort
Table 2.1 Common I
/
O redirec
t
ion
S
t
ring
U
s
age
De
s
crip
t
ion
>
cmd > file
Run
s
cmd and write
s
the output to file, overwriting whatever 
wa
s
in file.
>>
cmd >> file
Run
s
cmd and append
s
the output to the end of file.
<
cmd < file
Run
s
cmd, taking input from file.
|
cmd1 
|
cmd2
Run
s
cmd1 and pa
s
s
e
s
any output a
s
input to cmd2
6
Which takes a text string as an argument and writes to 
STDOUT
only input lines that contain that text.
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
NET example for how to delete several defined pages from a PDF document Dim detelePageindexes = New Integer() {1, 3, 5, 7, 9} ' Delete pages. All Rights Reserved
rotate pdf pages individually; save pdf rotate pages
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
doc2.InsertPages(pages, pageIndex) ' Output the new document how to use VB to insert an empty page to a specific location of current PDF file All Rights Reserved
pdf rotate single page reader; how to rotate all pages in pdf at once
U
s
e UNIX “f
i
lter” model
33
Most 
UNIX
utilities are written to support this mode of usage. They are known as
filter
s
as they read their input from 
STDIN
, filter the data in a particular way, and
write what is left to 
STDOUT
.
This is a concept that we can make good use of in our data munging programs.
If we write our programs so that they make no assumptions about the files that they
are reading and writing (or, indeed, whether they are even reading from and writing
to files) then we will have written a useful generic tool, which can be used in a num-
ber of different circumstances. 
Example
:
I
/
O
independence
Suppose, for example, that we had written a program called 
data_munger
which
munged data from one system into data suitable for use in another. Originally, we
might take data from a file and write our output to another. It might be tempting
to write a program that is called with two arguments which are the names of the
input and output files. The program would then be called like this:
data_munger input.dat output.dat
Within the script we would open the files and read from the input, munge the data,
and then write to the output file. In Perl, the program might look something like:
#!/usr/bin/perl –w
use strict;
my ($input, $output) = @ARGV;
open(IN, $input) || die "Can’t open $input for reading: $!";
open(OUT, ">$output") || die "Can’t open $output for writing: $!";
while (<IN>) {
print OUT munge_data($_);
}
close(IN) || die "Can't close $input: $!";
close(OUT) || die "Can't close $output: $!";
This will certainly work well for as long as we receive our input data in a file and are
expected to write our output data to another file. Perhaps at some point in the
future, the programmers responsible for our data source will announce that they
have written a new program called 
data_writer
, which we should now use to
extract data from their system. This program will write the extracted data to its
STDOUT
. At the same time the programmers responsible for our data sink announce
a new program called 
data_reader
, which we should use to load data into their
system and which reads the data to be loaded from 
STDIN
.
C# PDF Page Insert Library: insert pages into PDF file in C#.net
as how to merge PDF document files by C# code, how to rotate PDF document page This C# demo explains how to insert empty pages to a specific All Rights Reserved
how to save a pdf after rotating pages; rotate single page in pdf file
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
1. public void DeletePages(int[] pageIndexes). Description: Delete specified pages from the input PDF file. Parameters: All Rights Reserved.
reverse pdf page order online; pdf reverse page order
34
CHAPTER 
General mung
i
ng pract
i
ce
s
In order to use our program unchanged we will need to write some extra pieces
of code in the script which drives our program. Our program will need to be called
with code like this:
data_writer > input.dat
data_munger input.dat output.dat
data_reader < output.dat
This is already looking a little kludgy, but imagine if we had to make these changes
across a large number of systems. Perhaps there is a better way to write the origi-
nal program.
If we had assumed that the program reads from 
STDIN
and writes to 
STDOUT
, the
program actually gets simpler and more flexible. The rewritten program looks like this:
#!/usr/bin/perl –w
while (<STDIN>) {
print munge_data($_);
}
Note that we no longer have to open the input and output files explicitly, as Perl
arranges for 
STDIN
and 
STDOUT
to be opened for us. Also, the default file handle to
which the print function writes is 
STDOUT
; therefore, we no longer need to pass a
file handle to 
print
. This script is therefore much simpler than our original one.
When we’re dealing with input and output data files, our program is called
like this:
data_munger < input.dat > output.dat
and once the other systems want us to use their 
data_writer
and 
data_reader
programs, we can call our program like this:
data_writer | data_munger | data_reader
and everything will work exactly the same without any changes to our program. As
a bonus, if we have to cope with the introduction of 
data_writer
before
data_reader
or vice versa, we can easily call our program like this:
data_writer | data_munger > output.dat
or this:
data_munger < input.dat | data_reader
and everything will still work as expected.
Rather than using the 
STDIN
file handle, Perl allows you to make your program
even more flexible with no more work, by reading input from the null file handle
like this:
VB.NET PDF - WPF PDF Viewer for VB.NET Program
Users can rotate PDF pages, zoom in or zoom out PDF pages and go to any pages in easy ways box, note, underline, rectangle, polygon and so on are all can be
saving rotated pdf pages; rotate one page in pdf reader
C# WPF PDF Viewer SDK to view PDF document in C#.NET
PDF pages extract, copy, paste, C#.NET rotate PDF pages, C#.NET Compatible with all Windows systems and supports .NET NET WPF component able to rotate one PDF
how to rotate one page in pdf document; rotate pdf pages on ipad
U
s
e UNIX “f
i
lter” model
35
#!/usr/bin/perl –w
while (<>) {
print munged_data($_);
}
In this case, Perl will give your program each line of every file that is listed on your
command line. If there are no files on the command line, it reads from 
STDIN
. This
is exactly how most 
UNIX
filter programs work. If we rewrote our 
data_munger
program using this method we could call it in the following ways:
data_munger input.dat > output.dat
data_munger input.dat | data reader
in addition to the methods listed previously.
Example
:
I
/
O
chaining
Another advantage of the filter model is that it makes it easier to add new functional-
ity into your processing chain without having to change existing code. Suppose that
a system is sending you product data. You are loading this data into the database that
drives your company’s web site. You receive the data in a file called 
products.dat
and have written a script called 
load_products
. This script reads the data from
STDIN
, performs various data munging processes, and finally loads the data into the
database. The command that you run to load the file looks like this:
load_products < products.dat
What happens when the department that produces 
products.dat
announces that
because of a reorganization of their database they will be changing the format of
your input file? For example, perhaps they will no longer identify each product with
a unique integer, but with an alphanumeric code. Your first option would be to
rewrite 
load_products
to handle the new data format, but do you really want to
destabilize a script that has worked very well for a long time? Using the 
UNIX
filter
model, you don’t have to. You can write a new script called 
translate_products
which reads the new file format, translates the new product code to the product
identifiers that you are expecting, and writes the records in the original format to
STDOUT
. Your existing 
load_products
script can then read records in the format
that it accepts from 
STDIN
and can process them in exactly the same way that it
always has. The command line would look like this:
translate_products < products.dat | load_products
This method of working is known as chain exten
s
ion and can be very useful in a
number of areas.
VB.NET PDF - View PDF with WPF PDF Viewer for VB.NET
PDF pages extract, copy, paste, C#.NET rotate PDF pages, C#.NET Compatible with all Windows systems and supports .NET Able to rotate one PDF page or whole PDF
how to rotate a pdf page in reader; rotate single page in pdf
C# TIFF: How to Rotate TIFF Using C# Code in .NET Imaging
C#.NET PDF pages extract, copy, paste, C#.NET rotate PDF pages, C#.NET 0); page.Rotate(RotateOder.Clockwise90); doc.Save(@"C:\rotate.tif"); All Rights Reserved
rotate pages in pdf expert; how to rotate just one page in pdf
Wr
i
te aud
i
t tra
i
l
s
37
2.5.2 Sample audi
t
t
rail
A useful audit trail for a data munging process that takes data from a file and either
creates or updates database records might look like this:
Process: daily_upd started at 00:30:00 25 Mar 2000
Data source: /data/input/daily.dat
Data sink: database customer on server DATA_SERVER (using id 'maint')
Input record: D:CUS-00123
Action: Delete
Translation: CUS-00123 = database id 2364
Record 2364 deleted successfully
Input record: U:CUS-00124:Jones & Co| [etc …]
Action: Update
Translation: CUS-00124 = database id 2365
Record 2365 updated successfully
Input record: I:CUS-01000:Magnum Solutions Ltd| [etc …]
Action: Insert
Integrity Check: CUS-01000 does not exist on database
Record 3159 inserted successfully
[many lines omitted]
End of file on data source
1037 records processed (60 ins, 964 upd, 13 del)
Process: daily_upd complete at 00:43:14 25 Mar 2000
2.5.3 Using 
t
he 
UNIX
sys
t
em logs
Sometimes you will want to log your audit trail to the 
UNIX
system log. This is a
centralized process in which the administrator of a 
UNIX
system can control where
the log information for various processes is written. To access the system log from
Perl, use the 
Sys::Syslog
module. This module contains four functions called
openlog
closelog
setlogmask
, and 
syslog
which closely mirror the function-
ality of the 
UNIX
functions with the same names. For more details on these func-
tions, see the 
Sys::Syslog
module’s documentation and your 
UNIX
manual. Here
is an example of their use:
use Sys::Syslog;
openlog('data_munger.pl', 'cons', 'user');
# then later in the program
syslog('info', 'Process started');
# then later again
closelog();
Notice that as the system logger automatically timestamps all messages, we don’t
need to print the start time in our log message.
40
CHAPTER 
U
s
eful Perl 
i
d
i
om
s
There are a number of Perl idioms that will be useful in many data munging pro-
grams. Rather than introduce them in the text when they are first met, we will dis-
cuss them all here. 
3.1
Sor
t
ing
Sorting is one of the most common tasks that you will carry out when data mung-
ing. As you would expect, Perl makes sorting very easy for you, but there are a few
niceties that we’ll come to later in this section. 
3.1.1 Simple sor
t
s
Perl has a built-in 
sort
function which will handle simple sorts very easily. The syn-
tax for the 
sort
function is as follows:
@out = sort @in;
This takes the elements of the list 
@in
, sorts them lexically, and returns them in
array 
@out
. This is the simplest scenario. Normally you will want something more
complex, so 
sort
takes another argument which allows you to define the sort that
you want to perform. This argument is either the name of a subroutine or a block of
Perl code (enclosed in braces). For example, to sort data numerically1 you would
write code like this:
@out = sort numerically @in;
and a subroutine called 
numerically
which would look like this:
sub numerically {
return $a <=> $b;
}
There are a couple of things to notice in this subroutine. First, there are two special
variables, 
$a
and 
$b
, which are used in the subroutine. Each time Perl calls the sub-
routine, these variables are set to two of the values in the source array. Your subrou-
tine should compare these two values and return a value that indicates which of the
elements should come first in the sorted list. You should return 
–1
if 
$a
comes
before 
$b
1
if 
$b
comes before 
$a
, and 
0
if they are the same. The other thing to
notice is the 
<=>
operator which takes two values and returns 
–1
0
, or 
1
, depend-
ing on which value is numerically larger. This function, therefore, compares the two
values and returns the values required by 
sort
. If you wanted to sort the list in
1
Rather than lexically, where 100 comes before 2.
Documents you may be interested
Documents you may be interested