display pdf in asp.net page : Rotate all pages in pdf and save Library SDK class asp.net .net wpf ajax dmp28-part1836

Operator
s
261
Note, once again, that a hash slice returns a list and therefore is prefixed with 
@
. The
key list, however, is still delimited with 
{
and 
}
.
As a hash can be given values using a list, it is possible to use the 
map
function to
turn a list into a hash. For example, the following code creates a hash where the
keys are numbers and the values are their squares.
%squares = map { $_, $_ * $_ } @numbers;
B.2.4 More informa
t
ion
For more information about Perl data types, see the 
perldata
manual page.
B.3
Opera
t
ors
Perl has all of the operators that you will be familiar with from other languages—
and a few more besides. You can get a complete list of all of Perl’s operators in the
perlop
manual page. Let’s look at some of the operators in more detail.
B.3.1 Ma
t
hema
t
ical opera
t
ors
The operators 
+
-
*
, and 
/
will add, subtract, multiply, and divide their two oper-
ands respectively. 
%
will find the modulus of the two operands (that is the remainder
when integer division is carried out).
Unary minus (
-
) reverses the sign of its single operand.
Unary increment (
++
) and decrement (
--
) operators will add or subtract one
from their operands. These operators are available both in prefix and postfix ver-
sions. Both versions increment or decrement the operand, but the prefix versions
return the result after the operation and the postfix versions return the results
before the operation.
The exponentiation operator (
**
) raises its left-hand operand to the power given
by its right operand.
All of the binary mathematical operators are available in an assignment version.
For example,
$x += 5;
is exactly equivalent to writing
$x = $x + 5;
Similar to the mathematical operators, but working instead on strings, the concate-
nation operator (
.
) joins two strings and the string multiplication operator (
x
)
returns a string made of its left operand repeated the number of times given by its
right operand. For example,
Rotate all pages in pdf and save - 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#
reverse page order pdf; rotate pdf pages on ipad
Rotate all pages in pdf and save - 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
save pdf after rotating pages; rotate pdf pages
262
APPENDIX 
E
s
s
ent
i
al Perl
$y = 'hello' x 3;
results in 
$y
having the value “hellohellohello”.
In an array context, if the left operand is a list, then this operator acts as a list rep-
etition operator. For example,
@a = (0) x 100;
makes a list with 100 elements, each of which contains the number 0, and then
assigns it to 
@a
.
B.3.2 Logical opera
t
ors
Perl distinguishes between logical operators for use on numbers and logical opera-
tors for use on strings. The former set uses the mathematical symbols 
<
<=
==
!=
,
>=
, and 
>
for less than, less than or equal to, equal to, not equal to, greater than or
equal to, and greater than, respectively, whereas the string logical operators use 
lt
,
le
eq
ne
ge
, and 
gt
for the same operations. All of these operators return 
1
if
their operands satisfy the relationship and 
0
if they don’t. In addition, there are two
comparison operators 
<=>
(for numbers) and 
cmp
(for strings) which return 
–1
0
,
or 
1
depending on whether their first operand is less than, equal to, or greater than
their second operand.
For joining logical comparisons, Perl has the usual set of operators, but once
again it has two sets. The first set uses 
&&
for conjunction and 
||
for disjunction.
These operators have very high precedence. The second set uses the words 
and
and
or
. This set has very low precedence. The difference is best explained with an exam-
ple. When opening a file, it is very common in Perl to write something like this:
open DATA, 'file.dat' or die "Can't open file\n";
Notice that we have omitted the parentheses around the arguments to 
open
.
Because of the low precedence of 
or
, this code is interpreted as if we had written
open (DATA, 'file.dat') or die "Can't open file\n";
which is what we wanted. If we had used the high precedence version of the opera-
tor instead, like this
open DATA, 'file.dat' || die "Can't open file\n";
it would have bound more tightly than the comma that builds up the list of arguments
to 
open
. Our code would, therefore, have been interpreted as though we had written
open DATA, ('file.dat' || die "Can't open file\n");
which doesn’t achieve the correct result.
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
pdf rotate page; rotate pages in pdf and save
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
rotate pdf page by page; rotate pdf page and save
Flow of control
263
The previous example also demonstrates another feature of Perl’s logical opera-
tors—they are 
s
hort-circuiting. That is to say they only execute enough of the terms
to know what the overall result will be. In the case of the 
open
example, if the call
to 
open
is successful, then the left-hand side of the operator is true, which means
that the whole expression is true (as an 
or
operation is true if either of its operands
is true). The right-hand side (the call to 
die
) is therefore not called. If the call to
open
fails, then the left-hand side of the operator is false. The right-hand side must
therefore be executed in order to ascertain what the result is. This leads to a very
common idiom in Perl in which you will often see code like
execute_code() or handle_error();
Unusually, the logical operators are also available in assignment versions. The “or-
equals” operator is the most commonly used of these. It is used in code like
$value ||= 'default';
This can be expanded into
$value = $value || 'default';
from which it is obvious that the code sets 
$value
to a default value if it doesn’t
already have a value.
Perl also has bitwi
s
e logical operators for and (
&
) or (
|
), exclusive or (
^
), and nega-
tion (
~
). These work on the binary representation of their two operands and, there-
fore, don’t always give intuitively correct answers (for example 
~1
isn’t equal to 
0
).
There are also left (
<<
) and right (
>>
) shift operators for manipulating binary num-
bers. One use for these is to quickly multiply or divide numbers by a power of two.
B.4
Flow of con
t
rol
Perl has all of the standard flow of control constructs that are familiar from other
languages, but many of them have interesting variations.
B.4.1 Condi
t
ional execu
t
ion
The 
if
statement executes a piece of code only if an expression is true.
if ($location eq 'The Shire') {
$safety = 1;
}
The statement can be extended with an 
else
clause.
if ($location eq 'The Shire') {
$safety++;
} else {
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.
how to rotate one page in pdf document; rotate single page in pdf
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
rotate single page in pdf reader; rotate one page in pdf
264
APPENDIX 
E
s
s
ent
i
al Perl
$safety--;
}
And further extended with 
elsif
clauses.
if ($location eq 'The Shire') {
$safety++;
} elsif ($location eq 'Mordor') {
$safety = 0;
} else {
$safety--;
}
Perl also has an 
unless
statement which is logically opposite the 
if
statement—it
executes unless the condition is true.
unless ($location eq 'The Shire') {
$panic = 1;
}
Both the 
if
and 
unless
keywords can be used as 
s
tatement modifier
s
. This can
often make for more readable code.
$damage *= 2 if $name eq 'Aragorn';
$dexterity++ unless $name eq 'Sam';
B.4.2 Loops
Perl has a number of looping constructs to execute a piece of code a number of times.
for loop
The 
for
loop has the syntax:
for (initialisation; test; increment) {
statements;
}
For example,
for ($x = 1; $x <= 10; ++$x) {
print "$x squared is ", $x * $x, "\n";
}
The loop will execute until the test returns a false value. It is probably true to say
that this loop is very rarely used in Perl, as the 
foreach
loop discussed in the next
section is far more flexible.
C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net
Description: Copy specified page from the input PDF file pageIndexes, The page indexes of pages that will be copied, 0
rotate pdf page; rotate pdf page few degrees
C# Create PDF from Excel Library to convert xlsx, xls to PDF in C#
Merge all Excel sheets to one PDF file. Export PDF from Excel with cell border or no border. Description: Convert to PDF/TIFF and save it on the disk.
how to change page orientation in pdf document; how to reverse page order in pdf
Flow of control
265
foreach loop
The 
foreach
loop has the syntax:
foreach var (list) {
statements;
}
For example, the previous example can be rewritten as:
foreach my $x (1 .. 10) {
print "$x squared is ", $x * $x, "\n";
}
which, to many people, is easier to understand as it is less complex. You can even omit
the loop variable, in which case each element in the list in turn is accessible as 
$_
.
foreach (1 .. 10) {
print "$_ squared is ", $_ * $_, "\n";
}
This loop will execute until each element of the list has been processed. It is often
used for iterating across the contents of an array like this:
foreach (@data) {
process($_);
}
while loop
The 
while
loop has the syntax:
while (condition) {
statements
}
For example,
while ($data = get_data()) {
process($data);
}
This loop will execute until the condition evaluates to a false value.
Loop con
t
rol
There are three keywords which can be used to alter the normal execution of a
loop: 
next
last
, and 
redo
next
immediately starts the next iteration of the loop, starting with the evalua-
tion of any test which controls whether the loop should continue to be executed.
For example, to ignore empty elements of an array you can write code like this:
C# PDF File Merge Library: Merge, append PDF files in C#.net, ASP.
NET source code for combining multiple PDF pages together in Remarkably, all those C#.NET PDF document page processing source PDF streams into one PDF file and
how to rotate just one page in pdf; rotate pages in pdf expert
C# PDF Convert to Images SDK: Convert PDF to png, gif images in C#
Description: Convert all the PDF pages to target format images and save them into streams. Parameters: Name, Description, Valid Value.
rotate pages in pdf; permanently rotate pdf pages
266
APPENDIX 
E
s
s
ent
i
al Perl
foreach my $datum (@data) {
next unless $datum;
process($datum);
}
redo
also returns to the start of the loop block, but does not execute any test or
iteration code. Suppose you were prompting the user for ten pieces of data, none of
which could be blank. You could write code like this:
foreach my $input (1 .. 10) {
print "\n$input> ";
$_; = <STDIN>;
redo unless $_'
}
last
immediately exits the loop and continues execution on the statement follow-
ing the end of the loop. If you were processing data, but wanted to stop when you
reached a number that was negative, you could write code like this:
foreach my $datum (@data) {
last if $datum < 0;
process($datum);
}
All of these keywords act on the innermost enclosing loop by default. If this isn’t what
you want then you can put a label in front of the loop keyword (
for
foreach
, or
while
) and refer to it in the 
next
redo
, or 
last
command. For example, if you were
processing lines and words from a document, you could write something like this:
LINE:
foreach my $line (getlines()) {
WORD:
foreach $word (getwords($line)) {
last WORD if $word eq 'next';
last LINE if $word eq 'end';
process($word);
}
}
B.5
Subrou
t
ines
Subroutines are defined using the keyword 
sub
like this:
sub gollum {
print "We hatesss it forever!\n";
}
and are called like this:
Subrout
i
ne
s
267
&gollum;
or like this
gollum();
or (if the definition of the subroutine has already been seen by the compiler) like this:
gollum;
Within a subroutine, the parameters are available in the special array 
@_
. These
parameters are passed by reference, so changing this array will alter the values of the
variables in the calling code.4 To simulate parameter passing by value, it is usual to
assign the parameters to local variables within the subroutine like this:
sub example {
my ($arg1, $arg2, $arg4) = @_;
# Do stuff with $arg1, $arg2 and $arg3
}
Any arrays or hashes that are passed into subroutines this way are flattened into one
array. Therefore if you try to write code like this:
# Subroutine to print one element of an array
# N.B. This code doesn't work.
sub element {
my (@arr, $x) = @_;
print $arr[$x];
}
my @array = (1 .. 10);
element(@array, 4);
it won’t work because, within the subroutine, the assignment to 
@arr
doesn’t know
when to stop pulling elements from 
@_
and will, therefore, take all of 
@_
, leaving
nothing to go into 
$x
which therefore ends up containing the 
undef
value.
If you were to pass the parameters the other way round like this:
# Subroutine to print one element of an array
# N.B. Better than the previous version.
sub element {
my ($x, @arr) = @_;
print $arr[$x];
}
my @array = (1 .. 10);
element(4, @array);
4
This isn’t strictly true, but it’s true enough to be a reasonable working hypothesis. For the full gory details
see 
perldoc
perlsub
.
268
APPENDIX 
E
s
s
ent
i
al Perl
it would work, as the assignment to 
$x
would pull one element off of 
@_
leaving the
rest to go into 
@arr
. An even better way, however, is to use references, as we’ll see later.
A subroutine returns the value of the last statement that it executes, although
you can also use the 
return
function to explicitly return a value from any point in
the subroutine. The return value can be a scalar or a list. Perl even supplies a func-
tion called 
wantarray
which tells you whether your subroutine was called in scalar
or array context so that you can adjust your return value accordingly.
More information about creating and calling subroutines can be found in the
perlsub
manual page.
B.6
References
References are the key to building complex data structures in Perl and, as such, are
very important for data munging. They work somewhat like pointers in languages
like 
C
, but are more useful. They know, for example, the type of the object that they
are pointing at. A reference is a scalar value and can, therefore, be stored in a stan-
dard scalar variable.
B.6.1 Crea
t
ing references
You can create a reference to a variable in Perl by putting a backslash character (
\
)
in front of the variable name. For example:
$scalar = 'A scalar';
@array = ('An', 'Array');
%hash = (type => 'Hash);
$scalar_ref = \$scalar;
$array_ref = \@array;
$hash_ref = \%hash;
Sometimes you’d like a reference to an array or a hash, but you don’t wish to go to
the bother of creating a variable. In these cases, you can create an anonymou
s
array
or hash like this:
$array_ref = ['An', 'Array'];
$hash_ref = {type => 'Hash'};
The references created in this manner are no different than the ones created from
variables, and can be dereferenced in exactly the same ways.
Reference
s
269
B.6.2 Using references
To get back to the original object that the scalar points at, you simply put the
object’s type specifier character (i.e., 
$
@
, or 
%
) in front of the variable holding the
reference. For example:
$orig_scalar = $$scalar_ref;
@orig_array = @$array_ref;
%orig_hash = %$hash_ref;
If you have a reference to an array or a hash, you can access the contained elements
using the dereferencing operator (
->
). For example:
$array_element = $array_ref->[1];
$hash_element = $hash_ref->{type};
To find out what type of object a reference refers to, you can use the 
ref
function.
This function returns a string containing the name of the object type. For example:
print ref $scalar_ref; # prints 'SCALAR'
print ref $array_ref;
# prints 'ARRAY'
print ref $hash_ref;
# prints 'HASH'
B.6.3 References 
t
o subrou
t
ines
You can also take references to subroutines. The syntax is exactly equivalent for
other object types. Remember that the type specifier character for a subroutine is 
&
.
You can therefore do things like this:
sub my_sub {
print "I am a subroutine";
}
$sub_ref = \&my_sub;
&$sub_ref;
# executes &my_sub
$sub_ref->(); # another way to execute my_sub (allowing parameter passing)
You can use this to create references to anonymous subroutines (i.e., subroutines
without names) like this:
$sub_ref = sub { print "I'm an anonymous subroutine" };
Now the only way to execute this subroutine is via the reference.
B.6.4 Complex da
t
a s
t
ruc
t
ures using references
I said at the start of this section that references were the key to creating complex
data structures in Perl. Let’s take a look at why this is.
Recall that each element of an array or a hash can only contain scalar values. If
you tried to create a two-dimensional array with code like this:
270
APPENDIX 
E
s
s
ent
i
al Perl
# NOTE: This code doesn't work
@array_2d = ((1, 2, 3), (4, 5, 6), (7, ,8, 9));
the arrays would all be flattened and you would end up with a one-dimensional
array containing the numbers from one to nine. However, with references we now
have a way to refer to an array using a value which will fit into a scalar variable. We
can, therefore, do something like this:
@arr1 = (1, 2, 3);
@arr2 = (4, 5, 6);
@arr3 = (7, 8, 9);
@array_2d = (\@arr1, \@arr2, \@arr3);
or (without the need for intermediate array variables):
@array_2d = ([1, 2, 3],
[4, 5, 6],
[7, 8, 9]);
Of course, having put our data into a two-dimensional array,5 we need to know
how we get the data back out again. It should be possible to work this out, given
what we already know about arrays and references.
Suppose we want to access the central element of our 2-D array (the number 5).
Actually, our array isn’t a 2-D array at all, it is really an array which contains refer-
ences to arrays in its elements. The element 
$array_2d[1]
contains a reference to
an anonymous array which contains the numbers 4, 5, and 6. One way to do it
would, therefore, be to use an intermediate variable like this:
$row = $array_2d[1];
@row_arr = @$row;
$element = $row_arr[1];
While this will work, Perl gives us ways to write the same thing more efficiently. In
particular, the notation for accessing an object given a reference to it has some
extensions to it. Where previously we have seen syntax like 
@$arr_ref
give us the
array referred to by 
$arr_ref
, there is a more general syntax which looks like:
@{
b
l
o
c
k
}
in which block is any piece of Perl code that returns a reference to an array (the same
is true, incidentally, of hashes). In our case, we can, therefore, use this to our advan-
tage and use
@{$array_2d[1]}
5
Or, at least, something that simulates one rather well.
Documents you may be interested
Documents you may be interested