c# pdf viewer open source : How to reorder pdf pages in application SDK cloud html winforms azure class World%20of%20Warcraft%20Programming%20(2nd%20Edition)12-part1784

Chapter 5
Advanced Functions and Control Structures
79
Missing Return Values?
When you are working with multiple return values, a few odd things can
happen. Look at the following example:
> print(ConvertHexToRGB(“FFFFFF“))
1, 1, 1
> print(ConvertHexToRGB(“FFFFFF“), “SomeOtherArgument“)
1, SomeOtherArgument
Where did the other returns go? They were eaten by the following rule:
When a function call with multiple return values isthe last argument to another
function, or the last argument in a multiple assignment expression, all of the
return values are passed orused. Otherwise,only the first return value isused or
assigned.
You can see this behavior with the assignment operator in the following
example:
> a, b, c, d = ConvertHexToRGB(“FFFFFF“), “some“, “more“, “arguments“
> print(a, b, c, d)
1, some, more, arguments
Because the call to
ConvertHexToRGB()
is followed by additional values,
Lua only uses the first return from the function call. There are a few technical
reasonsforthis limitation,butitshouldnotaffectyouveryoften.Theexception
to the rule can be seen in the following example:
> a, b, c, d = “first argument“, ConvertHexToRGB(“FFFFFF“)
> print(a, b, c, d)
first argument, 1, 1, 1
TIP
When working with multiple return values, you can always wrap the function
call in parentheses to limitit to a single return value, as follows:
> print((ConvertHexToRGB(“FFFFFF“)))
1
Multiple Return Values in World of Warcraft
Several World of Warcraft API functions return multiple values.For example,
the function
GetRaidRosterInfo()
takes a character’s raid index (a number)
and returns the following information:
The name of the character
The character’s rank in the raid (leader, assistant, and so on)
What subgroup the character is in
How to reorder pdf pages in - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
move pdf pages in preview; reordering pages in pdf
How to reorder pdf pages in - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
how to move pages around in pdf; how to move pages around in pdf file
80
Part I
Learning to Program
The character’s level
The character’s class (localized)
The character’s class (capitalized, in English)
The name of the zone the character is currently in
Whether the character is online
Whether the character is dead
If the character is a main tank or main assist
Whether the character is master looter
This function provides a ton of information, but, typically, when you need
one of the items, you need more than one. In this case, it’s more efficient for
thegame clientto return each oftheseitemsevery timethe function is queried,
rather than having 11 different API functions.
SELECTING SPECIFIC VALUES
Functions with multiple return values provide a unique set of challenges, such
as how to get at values that aren’t at the start of the return list. There are
two easy ways to do this: using dummy variables and using the select()
statement.
Taking the ConvertHexToRGB() example, how could you extract just the
green value?
Using a Dummy Variable
The function is going to return three results regardless of how you call it, but
you can use dummy variables to throw away the results that aren’t interesting.
For example, you may see something that looks like this:
local _, g = ConvertHexToRGB(“FFFFFF“)
Because the underscore character is a valid identifier, it can be used to store
values, but most sane programs choose more valid variable names. The under-
score identifier has become somewhat of a de facto standard when you need
to throw away the result of a function call simply because it’s easy to type,
and most likely not already in use, but its use is still considered bad practice.
Instead of using the underscore as a dummy variable, it’s better to give each
variable a meaningful name, and only use those that are necessary. That way if
you ever need to look at that code in the future, you have a hint of what other
information is available. Some situations can’t be handled using this method,
but Lua provides a utility function to compensate.
(continued)
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview. Reorder TIFF Pages in C#.NET Application.
rearrange pdf pages in reader; move pages in pdf online
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
just following attached links. C# PDF: Add, Delete, Reorder PDF Pages Using C#.NET, C# PDF: Merge or Split PDF Files Using C#.NET.
how to move pages within a pdf; change page order pdf reader
Chapter 5
Advanced Functions and Control Structures
81
SELECTING SPECIFIC VALUES (continued)
Using the select() Function
The select() function was designed to help solve this problem, by allowing
you to choose a specific argument from a given list. This function takes any
number of arguments, the first of which tells the function what to do. When
select() is passed the “#“ string as the first argument, it simply returns
the number of arguments in the second part of the function. If select() is
passed a number value, it returns that argument from the list, followed by
anything after it. After this initial argument, select() takes any number of
arguments, comma separated.
Confused yet? Look at a few examples:
> print(select(“#“, “alpha“, “beta“, “gamma“))
3
> print(select(1, “alpha“, “beta“, “gamma“))
alpha, beta, gamma
> print(select(2, “alpha“, “beta“, “gamma“))
beta, gamma
> print(select(3, “alpha“, “beta“, “gamma“))
gamma
> third = select(3, “alpha“, “beta“, “gamma“)
> print(third)
gamma
If you just need to get a single value from the list, you can assign it directly
to the variable, or wrap the select() call in parentheses so the extra values
are thrown away.
You may find this function useful when working with some of the longer
World of Warcraft API functions, such as GetRaidRosterInfo(). If you only
need a single return, you can isolate it using a call to select().
Accepting a Variable Number of Arguments
Many functions are designed to take a specific number of arguments, such
as the
tonumber()
function, which takes a string, and optionally, a number
base for the conversion. Other functions make more sense when they accept
a variable number of arguments. Consider a function that calculates the
arithmetic mean of a set of numbers. A simple version of this function that
works with two arguments might look something like this:
function mean(num1, num2)
return (num1 + num2) / 2
end
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
Sort and Reorder PowerPoint Slides Range with VB amount of robust PPT slides/pages editing methods powerful & profession imaging controls, PDF document, image
how to rearrange pdf pages in preview; how to move pages in a pdf
VB.NET PDF: Create PDF Document Viewer in C#.NET for Document
Support navigating to the previous or next page of the PDF document; Able to insert, delete or reorder PDF document page in VB.NET document viewer;
reorder pdf pages in preview; reorder pdf pages online
82
Part I
Learning to Program
Unfortunately, if you need to compute the mean of three numbers, you
would need to do it manually, call the function twice, or write a new function
that takes three arguments instead. As you can imagine, this is highly ineffi-
cient,and Lua provides an easier way to write thesetypes offunctions so they
can accept a variable number of arguments.
Declaring a Vararg Function
Functions with a variable number of arguments are called vararg functions for
short, and they use an ellipsis (three periods) in their function declaration to
indicate they take any number of arguments.
In Lua, the ellipsis can only appear as the last argument in a function
declaration. Whenever the ellipsis is then used in the body of the function,
the arguments that were supplied in the
vararg
slot are substituted. Take the
print()
function, which already accepts a variable numberof arguments, and
extend it by running the following code:
function test_print(...)
print(“testing“, ...)
end
This function takes in any number of arguments and then passes them to
the
print()
function, adding its own text to the start of the list. The output
from running this function looks like this:
> test_print(“alpha“, “beta“, 13, “gamma“)
testing, alpha, beta, 13, gamma
When the function is run and Lua encounters the ... symbol, it replaces it
with the list of arguments that were passed to the function. As a result, it can
be used in the following ways:
-- Pass the arguments to another function
print(...)
-- Assign the arguments to variables
local var1, var2, var3 = ...
-- Construct a new table with the arguments
local tbl = {...}
The preceding example could be used to make a new function called
newtable()
,which takes in a set of arguments and makes a new table with
those arguments in the array part of the table:
function newtable(...)
return {...}
end
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
page, it is also featured with the functions to merge PDF files using C# .NET, add new PDF page, delete certain PDF page, reorder existing PDF pages and split
how to move pages in pdf files; move pages in pdf document
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
Users can use it to reorder TIFF pages in ''' &ltsummary> ''' Sort TIFF document pages in designed powerful & profession imaging controls, PDF document, image
reorder pages pdf file; how to change page order in pdf document
Chapter 5
Advanced Functions and Control Structures
83
Test this function now:
> tbl = newtable(“alpha“, “beta“, “gamma“)
> for i=1, #tbl do
>> print(i, tbl[i])
>> end
1, alpha
2, beta
3, gamma
Using select() with ...
The
select()
function makes working with vararg functions very easy,
because it can provide the number of arguments passed, as well as allow you
to easily iterate through them without needing to assign them to variables.
Consider the following function thattakes a list ofarguments and prints a line
for each argument including the index and the argument itself:
function printargs(...)
local num_args = select(“#“, ...)
for i=1, num_args do
local arg = select(i, ...)
print(i, arg)
end
end
Sample output:
> printargs(“alpha“, “beta“, 13, “gamma“)
1, alpha
2, beta
3, 13
4, gamma
This method lets you avoid creating a new table every single time, and
allows the value
nil
to be passed as an argument. Remember that the length
operator and the table library functions are only reliable when the array table
does not contain any ‘‘holes’’ in the form of
nil
values. Run the following
function definitions in your interpreter:
function test1(...)
local tbl = {...}
for i = 1, #tbl do
print(i, tbl[i])
end
end
function test2(...)
for i = 1, select(“#“, ...) do
VB.NET PDF: VB.NET Guide to Process PDF Document in .NET Project
It can be used to add or delete PDF document page(s), sort the order of PDF pages, add image to PDF document page and extract page(s) from PDF document in VB
reorder pages in pdf reader; change pdf page order reader
.NET Multipage TIFF SDK| Process Multipage TIFF Files
SDK, developers are easily to access, extract, swap, reorder, insert, mark up and delete pages in any multi upload to SharePoint and save to PDF documents.
reorder pages in a pdf; pdf reverse page order
84
Part I
Learning to Program
print(i, (select(i, ...)))
end
end
You can see an example of this issue by running the following:
> test1(“alpha“, “beta“, “gamma“, nil)
1, alpha
2, beta
3, gamma
> test2(“alpha“, “beta“, “gamma“, nil)
1, alpha
2, beta
3, gamma
4, nil
The first example stuffs the arguments into a table and then tries to get the
length of the table. Because there is a nil value in the middle of the table,
getting the length could return either twoor four. This sortof unpredictability
is specifically why you should use the second example.
In addition the first function needs to create a new table on each call, which
willallocateandusemorememoryin the longrun.Theversionusing
select()
has no such hidden cost.
Generic for Loops and Iterators
Chapter 3 introduced the
for
statement,which allows you to repeata compu-
tation over a series of numbers by supplying a start value, end value, and a
value by which toincrementthe counter aftereach loop. Chapter 4 introduced
storing data in both the array part and the hash part of Lua tables. Until this
point there has been no way to loop through the elements of the hash part
of the table, but Lua provides a more generic form of the
for
statement that,
when combined with an iterator function, allows just that.
Wikipedia defines an iterator as ‘‘an object which allows a programmer
to traverse through all elements of a collection, regardless of its specific
implementation.’’ In Lua specifically, you use an iterator function along with
some extra information to loop through a collection.
Syntax of Generic for
The generic
for
loop syntax is a bit different than the numeric
for
loop:
for val1, val2, val3, ... in <expression> do
-- body of for loop
end
Chapter 5
Advanced Functions and Control Structures
85
Ageneric
for
loop can return many variables on each iteration (as many as
definedby the iteratorfunction, actually). Immediately afterthe
for
keyword,
you supply a list of variable names that are used to store the returns on each
iteration of the loop. The generic loop then determines what to traverse by
evaluating
<expression>
,which should return the following three values:
An iterator function that can be called on each iteration of the loop
state, used by the iterator function on each subsequent call
An initial value for the iterator value
Luckily, unless you plan to write your own iterator functions, you won’t
have to deal with any of this directly. A number of prewritten functions will
create your iterators for you.
Traversing the Array Part of a Table
ipairs()
is one such function that allows you to traverse the array part of
atable without using the numeric
for
loop. Some programmers prefer this
syntax to that of the numeric
for
loop. Run the following example:
> tbl = {“alpha“, “beta“, “gamma“}
> for idx, value in ipairs(tbl) do
>> print(idx, value)
>> end
1, alpha
2, beta
3, gamma
The
ipairs()
function takes a table and returns all the information the
for
loop requires to traverse the array part of the table, including the iterator
function itself. Each call to the iterator function returns the numeric index of
the element, and the element itself. These variables can be named whatever
you’d like and,as always, are local to the scope of the
for
loop (meaning they
cannot be accessed outside of that scope).
You can explore the
ipairs()
function a bit more by running the following
in your interpreter:
> print(ipairs(tbl))
function: 0x300980, table: 0x3072c0, 0
> print(tbl)
table: 0x3072c0
Itappearsthe
ipairs()
functionreturnsan iteratorfunction, thestate (in this
case it’s just the table you passed in), and the initial value for the iterator (
0
).
There’s no real magic going on here, just a useful function allowing you to
loopthrough array tables.
86
Part I
Learning to Program
Traversing an Entire Table
Another function,called
pairs()
,allows you to traverse a table in its entirety,
including both the array part and the hash table part. The usage is the same as
ipairs()
;just pass it the table and use it as part of a generic
for
loop:
> tbl = {“alpha“, “beta“, [“one“] = “uno“, [“two“] = “dos“}
> for key, value in pairs(tbl) do
>> print(key, value)
>> end
1, alpha
2, beta
one, uno
two, dos
TRAVERSING USING PAIRS()
In the preceding example, the pairs() function seemed to traverse the
table in the order the elements were added to the table, but this is just a
coincidence. The specific order in which elements will be visited is unspecified
by this function, even for numeric keys. If you specifically need to traverse
the table’s numeric elements in order, you should instead use the ipairs()
function, which can guarantee this. The lack of order when using pairs() is
due to the way hash tables are implemented, as a collection of associated
key/value pairs with no internal order.
When using the pairs() function, you must ensure you don’t add any ele-
ments to the table. This is because pairs() calls the next() function, which
carries the following warning in the Lua 5.1 Reference Manual:
‘‘The behavior of next is undefined if, during the traversal, you assign any
value to a nonexistent field in the table. You may, however, modify existing
fields. In particular, you may clear existing fields.’’
If you add an element to the table during the traversal, the iteration may
simply not work, it may terminate early, or it may throw an error. It’s important
to keep this in mind when working with an iteration using pairs().
In addition, you may encounter an error if you try to clear a key that was not
previously set by assigning nil to it. This is due to the way tables are imple-
mented. In general you should ensure you only ever assign to keys that existed
prior to the iteration.
Clearing a Table
As stated in the Lua 5.1 Reference Manual for
next()
, you can clear the
elements of a table while traversing it using
pairs()
.The following code will
clear a table of all set elements:
for key, value in pairs(tbl) do
Chapter 5
Advanced Functions and Control Structures
87
tbl[key] = nil
end
Because
pairs()
works for all keys of a table, this is a quick way to ensure
you’ve cleared all elements (in the event you need to re-use a table, for
example). Note that this is different than just running
tbl = {}
,which would
create a new table entirely, rather than clearing the existing table.You can see
this by printing the value of the table before and after, and verifying that they
are different:
> tbl = {“alpha“, “beta“, “gamma“}
> print(tbl)
table: 0x131800
> tbl = {}
table: 0x131ac0
Using Other Iterators
A number of other functions in Lua can be used to generate iterators that
are extremely useful. The
string.gmatch()
function can be used with Lua
pattern matching to create iterators over strings, and specific matches within
that string. You learn more about this function and Lua pattern matching in
Chapter 6, but here are some examples:
> for word in string.gmatch(“These are some words“, “%S+“) do
>> print(word)
>> end
These
are
some
words
> for char in string.gmatch(“Hello!“, “.“) do
>> print(char)
>> end
H
e
l
l
o
!
Sorting an Array of Table Data
The built-in
table.sort()
function only allows youto sort number and string
data by default. Fortunately,
table.sort()
enables you to pass in a function to
do the actual comparisons between elements, with the library function doing
the overall sortbasedon the results of yourfunction.Thismeansyoucan write
your own function to determine which of two tables is bigger when itcomes to
sorting.
88
Part I
Learning to Program
Define Example Data
For the examples in this section you need some sample data to sort. Define the
following in your Lua interpreter:
guild = {}
table.insert(guild, {
name = “Cladhaire“,
class = “Rogue“,
level = 80,
})
table.insert(guild, {
name = “Draoi“,
class = “Druid“,
level = 80,
})
table.insert(guild, {
name = “Deathsquid“,
class = “Deathknight“,
level = 68,
})
Default Sort Order
By default, this list is sorted in the order it was inserted, because it’s using the
array part of the table. Run the following to verify this:
> for idx, value in ipairs(guild) do
>> print(idx, value.name)
>> end
1, Cladhaire
2, Draoi
3, Deathsquid
Rather than print
value
itself, which would show
table: 0x3003a0
instead
of something meaningful, this code indexes the table and prints the value
associated with the key
name
.This code segment could be altered to print the
class, or the level if so desired.
Creating a Comparison Function
If you try to sort this data using
table.sort()
,you will get an error because
Lua doesn’t know howto compare table values (to determine what makes one
table less than another).
> table.sort(guild)
attempt to compare two table values
Documents you may be interested
Documents you may be interested