asp.net mvc display pdf : Change font size in pdf file application software tool html windows wpf online Manning%20-%20Code%20Generation%20in%20Action20-part1340

172
C
H
A
P
T E R
9
Handling data
9.1 Code generation versus a library y 172
9.2 A case study: a simple CSV-reading 
example 173
9.3 Technique: data adapters s 186
9.4 Technique: binary file reader/
writer 187
9.5 Finding tools to do it for you u 189
9.6 Summary 189
Code that reads and writes data formats can be created by code generation techniques.
The up-front benefit with a generator is that you can feel confident that you won’t
get the keyboard entry errors that turn a long into an int and take two days to find.
But the real value of using code generation for data handling is in the use of an abstract
file definition.
From this abstract definition, you can generate code for the file format in a variety
of languages and generate conversion routines, as well as documentation or test data.
For example, given a single abstract definition for a file format, we could create
libraries that read and write the format for C, Java, and Perl. Another example is
creating data adapter code that builds data-munging code to convert data from one
format to another.
In this chapter, we show you several generation strategies based on this philosophy
of using an abstract definition for your file formats.
9.1
C
ODE
GENERATION
VERSUS
A
LIBRARY
File format reading is usually done with a library, so why use code generation? Let’s
start by looking at the library approach. There are two strategies for building a library
to support a file format. The first is simply to write the library with the text or binary
structures implicit in the code. This is by far the most common technique.
Change font size in pdf file - Compress reduce PDF size in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
C# Code & .NET API to Compress & Decompress PDF Document
change pdf page size; 300 dpi pdf file size
Change font size in pdf file - VB.NET PDF File Compress Library: Compress reduce PDF size in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET PDF Document Compression and Decompression Control SDK
pdf compression; pdf custom paper size
CASE
STUDY
A
SIMPLE
CSV-
READING
EXAMPLE
173
With the second technique, you have the library read in a definition of the file for-
mat and then adjust its behavior to read the incoming stream. This library has to be
pretty complex to handle a range of file formats. It also locks up a lot of design in the
library itself that can’t be ported to other languages.
Most of the logic required to generate a file reader is available in a variety of
languages. File I/O is fairly similar across the common languages. The base data types
and the file I/O handling classes or routines change names, but the idea is pretty much
the same.
Using a generator, you can create an abstract definition of your file format and
generate implementations of that format in several languages. No single language
implementation technique offers the same reward.
In the case study portion of this chapter, we’ll build a generator that builds comma-
separated value (CSV) readers. In addition, we cover generation data translators and
binary file reader/writers.
9.2
CASE
STUDY
A
SIMPLE
CSV-
READING
EXAMPLE
Our case study generator builds a file reader that reads a list of names and ages from a
CSV file. It’s a simple example, but it provides a context for additional functionality as
your requirements for data import, export, and translation expand. Let’s start with an
example of our file format:
"Jack","D","Herrington",34
"Lauren","C","Herrington",32
"Megan","M","Herrington,",1
As you can see, this file contains four fields (first name, middle name, last name, and
age) separated by commas. You can use quotes in strings to avoid confusion when you
have commas inside the data.
If you were to write an XML document that would describe your comma-separated
format, it would look like this:
<spec>
<entity  name="Name">                                             
<field name="first_name" type="String" user="First Name" />     
<field name="middle_initial" type="String" user="Middle Initial" />  
<field name="last_name" type="String" user="Last Name" />            
<field name="age" type="Integer" user="Age" />                       
</entity>                                                                           
</spec>
Name is the one entity defined in the file. The Name entity includes four fields:
first_name, middle_initial, last_name, and age. Each field is defined with its type and
username. To keep it simple, let’s define the type using Java types.
In the next section, we’ll look at what you can expect this generator to do for you.
Specifies a Reader class 
to read Name objects
Fields and
types
C# PDF Sticky Note Library: add, delete, update PDF note in C#.net
Allow users to add comments online in ASPX webpage. Able to change font size in PDF comment box. Able to save and print sticky notes in PDF file.
pdf change page size; change font size in fillable pdf form
C# PDF insert text Library: insert text into PDF content in C#.net
existing scanned PDF text. Ability to change text font, color, size and location and output a new PDF document. XDoc.PDF for .NET
compress pdf; change page size pdf
174
CHAPTER 9
H
ANDLING
DATA
9.2.1
Roles of the generator
Before we begin, let’s list what the generator will do:
• Generate the code that will handle reading the CSV data and storing its contents
in memory.
• Check errors while reading the data.
• Produce the technical documentation for any classes that are created.
The generator does not need to:
• Document the structure of the file.
• Write data in the output file format.
• Handle cross-field validation.
• Validate the entire data set.
• Validate the data set against any other internal system resource.
Now you can address the architecture of the generator that will fulfill these requirements.
9.2.2
Laying out the generator architecture
We chose to use a partial-class generator model for the CSV reader generator because
we want to build classes that are designed to be extended from an abstract model of the
file format. The generator takes the definition of the file format and builds a Java file
that reads that format. It uses one template for the Java file and one template for each of
the different field types. The output of the templates is written into the Java file to com-
plete the generation cycle. Figure 9.1 shows the block architecture of the generator.
Next let’s look at the steps this generator will go through as it executes.
Generator
Reader
JavaBaseClass
FileDefinition
type.integer
type.string
CustomClass
Application
CSVdatafile
Figure 9.1
A generator that 
builds Java classes 
to read CSV files
C# PDF Field Edit Library: insert, delete, update pdf form field
Able to add text field to specified PDF file position in C#.NET class. Support to change font size in PDF form. Able to delete form fields from adobe PDF file.
change paper size pdf; advanced pdf compressor
C# PDF Text Box Edit Library: add, delete, update PDF text box in
Support to change font color in PDF text box. Ability to change text size in PDF text box. Adding text box is another way to add text to PDF page.
pdf reduce file size; pdf files optimized
CASE
STUDY
A
SIMPLE
CSV-
READING
EXAMPLE
175
9.2.3
Processing flow
Here are the process steps used by the generator:
Reads in the file definition XML and stores it locally.
Follows these steps for each entity:
Invokes the Reader template with the entity name, the class name, and the 
fields. The Reader template uses the type templates to build the basic 
processing steps for each field.
Stores the output of the Reader template in the correct Java file.
Now you’re ready to build the code for your generator.
9.2.4
Building the code for the CSV reader generator
The generator uses Rexml to read the description of the CSV format into memory. It
then uses the ERb text-template system to build the Java classes. Listing 9.1 shows the
code for the CSV reader generator.
require "rexml/document"                           
require "erb/erb"                                 
require "ftools"
Field = Struct.new( "Field", :java_name, :java_type, :user_name )    
def read_def_file( file_name )
doc = REXML::Document.new( File.open( file_name ) )              
doc.root.each_element( "entity" ) { |entity _node|               
entity = entity_node.attributes[ "entity" ].to                  
class_name = "#{entity}Reader"                                  
fields = []                                                     
entity_node.each_element( "field" ) { |field_node|              
field = Field.new();                                          
field.java_name = field_node.attributes[ "name" ].to_s        
field.java_type = field_node.attributes[ "type" ].to_s        
field.user_name = field_node.attributes[ "user" ].to_s        
fields.push( field )                                          
}
template_result = run_template( "Reader.java.template", binding ) 
dir = File.dirname( file_name )                                   
out_file_name = "#{dir}/#{class_name}.java"                       
print "Creating #{out_file_name}...\n"                            
fh = File.open( "#{out_file_name}", "w" )                         
fh.print template_result                                          
fh.close()                                                        
CSV reader generator
Listing 9.1 1 csvgen.rb
Saves the 
template 
output
r
w
Creates the
Field class
q
Runs the
template
e
Includes the 
XML parser
Includes the 
ERb system
Parses the 
input XML
Parses 
the 
XML
C# PDF Annotate Library: Draw, edit PDF annotation, markups in C#.
Able to edit and change PDF annotation properties such as font size or color. Abilities to draw markups on PDF document or stamp on PDF file.
change font size fillable pdf; pdf page size dimensions
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
PDF document, keeps the elements (like images, tables and chats) of original PDF file and maintains the original text style (including font, size, color, links
change font size in pdf comment box; can pdf files be compressed
176
CHAPTER 9
H
ANDLING
DATA
}                                                                                  
end
def run_template( template_name, bind )      
erb = ERb.new( File.new( "templates/#{template_name}" ).read )
return erb.result( bind )                                                          
end
if ARGV[0]
read_def_file( ARGV[ 0 ] )   
else
print "Must specify an input C file\n"
end
q
The Struct Ruby class builds a new class with the specified fields. The fields are both
readable and writable using the . syntax. This use of Struct creates a new class
called Field that has the member variables java_namejava_type, and
user_name.
w
This section parses the XML into a class name, an entity name, and an array of fields
where each field is specified using a Field object.
e
The call to run_template builds the Java file using Reader.java.template
(This template is described in listing 9.2.)
r
This code creates the Java file with the result of the template. 
Next you build the template (listing 9.2) for the Reader Java class, which is used by
the generator to build a CSV reader class. The template makes extensive use of iterators
to create data members and handlers for all the fields.
import java.io.*;
import java.util.*;
/**
* This is the base class for the CSV reader. You should derive your class 
from this
* and make any modifications you like.
*/
public class <%= class_name %> {
/**
* The data structure class                                        
*/
public class <%= entity %>
{
<% fields.each { |field| %>
/**
* The <%= field.user_name %>
*/
ERb template 
helper function
Sends the command-line 
argument to the generator
Listing 9.2 2 Reader.java.template
Shows the interior 
data structure class
q
C# PDF File Split Library: Split, seperate PDF into multiple files
RasterEdge.Imaging.Drawing.dll. RasterEdge.Imaging.Font.dll. This C# sample codes explain how to split a PDF file into multiple ones by output PDF file size.
pdf form change font size; adjust file size of pdf
VB.NET PDF File Split Library: Split, seperate PDF into multiple
RasterEdge.Imaging.Drawing.dll. RasterEdge.Imaging.Font.dll. This VB.NET sample codes explain how to split a PDF file into multiple ones by output PDF file size.
pdf font size change; best compression pdf
CASE
STUDY
A
SIMPLE
CSV-
READING
EXAMPLE
177
public <%= field.java_type %> <%= field.java_name %>;
<% } %>
}
/**
The input stream
*/
private InputStream _in;                                            
/**
* The finished data input.
*/
private ArrayList _data;                                            
public <%= class_name %>( InputStream in )                          
{
_in = in;
_data = new ArrayList();
}
/**
* size returns the count of data rows found in the input.
*/
public int size()
{
return _data.size();
}
/**
* Returns the '<%= entity %>' object for the specified row.
*/
public <%= entity %> get( int index )
{
return (<%= entity %>)_data.get( index );
}
/**                                                                 
* Reads in the input stream
*/
public void read()
 {
StringBuffer line = new StringBuffer();
line.setLength( 0 );
  try {
while( true )
{
int nChar;
if ( ( nChar = _in.read() ) == -1 )
break;
 char cChar = (char)nChar;
       if ( cChar == '' )
Shows the input stream 
for the CSV data
w
Shows the resulting output data
e
Shows the constructor 
for CSV reader class
r
Reads and stores the data
t
178
CHAPTER 9
H
ANDLING
DATA
{
process_line( line );
line.setLength( 0 );
}
else
{
line.append( cChar );
}
}
}
catch( IOException except )
{
if ( line.length() > 0 )
process_line( line );
}
}
 /**
* Processes a single input line.
*
* @arg line The row text
*/
protected void process_line( StringBuffer line )                   
{
ArrayList fields = new ArrayList();
boolean inQuotes = false;
boolean escaped = false;
StringBuffer text = new StringBuffer();
for( int index = 0; index < line.length(); index++ )
{
if ( escaped )
{
text.append( line.charAt( index ) );
}
else
{
if ( line.charAt( index ) == '' )
{
inQuotes = inQuotes ? false : true;
}
else if ( line.charAt( index ) == '\' )
{
escaped = true;
}
else if ( line.charAt( index ) == ',' && ! inQuotes )
{
fields.add( new String( text ) );
text.setLength( 0 );
}
else
{
text.append( line.charAt( index ) );
}
 }
Handles a single 
line of data
y
CASE
STUDY
A
SIMPLE
CSV-
READING
EXAMPLE
179
}
if ( text.length() > 0 )
fields.add( new String( text ) );
String strArray [] = new String[ fields.size() ];
fields.toArray( strArray );
process_fields( strArray );
 }
/**
* This is the main processor for a single row of string fields
*
* @arg fields The array of strings that make up the row.
*/
protected void process_fields( String fields[] )                   
{
<%= entity %> data = newRecord();
<% fields.each_index { |index| field = fields[ index ] %>
data.<%= field.java_name %> = process_<%= field.java_name %>( fields[ 
<%= index %> ] );
<% } %>
addRecord( data );
}
/**
* Creates a new record
*/
protected <%= entity %> newRecord( ) { return new <%= entity %>(); }
<% fields.each { |field| %>                                          
/**
* Processes the <%= field.user_name %>
*
* @arg <%= field.java_name %> The <%= field.user_name %>
*/
protected <%= field.java_type %> process_<%= field.java_name %>( String 
<%= field.java_name %> ) {
<%= run_template( "type.#{field.java_type.downcase}.template", binding 
).strip! %>
}
<% } %>
/**
* Adds a record to the data collection
*
* @arg data The new record
*/
protected void addRecord( <%= entity %> data ) { _data.add( data ); }
}
process_fields 
handles each field 
u
Creates handlers 
for each field
i
180
CHAPTER 9
H
ANDLING
DATA
q
This portion of the template builds the entity class that will represent one record from
the data.
w
The _in member variable is the input stream from which the class reads the CSV input.
e
The _data member variable is an ArrayList that hold references to all of the entity
classes created when you read the file.
r
This code builds the constructor for this class.
t
read is the main entry point for the class. It reads the file and parses the data into the
data array.
y
process_line handles processing one line of the CSV file. The method uses a state
machine to build each field into an array of strings.
u
process_fields takes the strings from process_line and puts them one by
one into the fields of the new entity object. The generator creates process meth-
ods for all of the fields, and they populate each field stored in memory with data of the
correct type. You can override these in your derived class to create custom field processing.
i
This section of the template builds the process methods for each field. The template
uses run_template to invoke the correct template for the type of the field. 
Each data type has its own template to get the return value in the class. This is the tem-
plate used to build the contents of the process method for an integer field:
return Integer.getInteger( <%= field.java_name %> );
The template for a string type is shown here:
return <%= field.java_name %>;
Next you create the Java class. It’s a class called NameReader—the Name portion
comes from the XML definition. Within this class is another class called Name that
represents a single line of CSV information. The iterator in the template builds the
fields within the Name class. The Java class definition then continues on into the heart
of the reader, where you define the constructor, the I/O mechanism, and the individual
handlers for each field. These handlers are built using iterators that cover each field in
the definition XML. Listing 9.3 shows the generated Java class for your CSV format.
import java.io.*;
import java.util.*;
/**
* This is the base class for the CSV reader. You should derive your class 
from this
* and make any modifications you like.
*/
Listing 9.3 3 Reader.java.template output
CASE
STUDY
A
SIMPLE
CSV-
READING
EXAMPLE
181
public class NameReader {
/**
* The data structure class
*/                                                                 
public class Name                                                   
{
/**                                                               
* The First Name
*/ 
public String first_name;
/**
* The Middle Initial
*/
public String middle_initial;
/**
* The Last Name 
*/
public String last_name;
/**
* The Age
*/
public Integer age;
/**
* The input stream
*/
private InputStream _in;
/**
* The finished data input.
*/
private ArrayList _data; 
public Reader( InputStream in )                                     
{
_in = in;                                                         
_data = new ArrayList();                                          
}
/**
* size returns the count of data rows found in the input.
*/ 
public int size()
{
return _data.size();
}
/**                                                                 
* Returns the 'Name' object for the specified row.                 
The interior data 
structure class
q
The new 
constructor
w
The data 
accessor
e
Documents you may be interested
Documents you may be interested