c# web api pdf : How to add bookmarks to pdf document SDK software service wpf winforms .net dnn BerkeleyDB-JE-GSG10-part692

Library Version 12.1.6.0
Database Records
12/7/2015
Getting Started with JE
Page 92
// The data data
MyData data2Store = new MyData();
data2Store.setLong(123456789l);
data2Store.setDouble(1234.9876543);
data2Store.setDescription("A test instance of this class");
try {
// Environment open omitted for brevity
// Open the database that you will use to store your data
DatabaseConfig myDbConfig = new DatabaseConfig();
myDbConfig.setAllowCreate(true);
myDbConfig.setSortedDuplicates(true);
Database myDatabase = myDbEnv.openDatabase(null, "myDb", myDbConfig);
// Open the database that you use to store your class information.
// The db used to store class information does not require duplicates
// support.
myDbConfig.setSortedDuplicates(false);
Database myClassDb = myDbEnv.openDatabase(null, "classDb", 
myDbConfig); 
// Instantiate the class catalog
StoredClassCatalog classCatalog = new StoredClassCatalog(myClassDb);
// Create the binding
EntryBinding dataBinding = new SerialBinding(classCatalog, 
MyData.class);
// Create the DatabaseEntry for the key
DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));
// Create the DatabaseEntry for the data. Use the EntryBinding object
// that was just created to populate the DatabaseEntry
DatabaseEntry theData = new DatabaseEntry();
dataBinding.objectToEntry(data2Store, theData);
// Put it as normal
myDatabase.put(null, theKey, theData);
// Database and environment close omitted for brevity 
} catch (Exception e) {
// Exception handling goes here
}
How to add bookmarks to pdf document - add, remove, update PDF bookmarks in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your C# Project with Rapid PDF Internal Navigation Via Bookmark and Outline
add bookmarks to pdf online; create bookmarks in pdf from excel
How to add bookmarks to pdf document - VB.NET PDF bookmark library: add, remove, update PDF bookmarks in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your VB.NET Project with Rapid PDF Internal Navigation Via Bookmark and Outline
delete bookmarks pdf; create bookmarks pdf file
Library Version 12.1.6.0
Database Records
12/7/2015
Getting Started with JE
Page 93
Deserializing Objects
Once an object is stored in the database, you can retrieve the MyData objects from the
retrieved DatabaseEntry using the Bind APIs in much the same way as is described above. For
example:
package je.gettingStarted;
import com.sleepycat.bind.EntryBinding;
import com.sleepycat.bind.serial.StoredClassCatalog;
import com.sleepycat.bind.serial.SerialBinding;
import com.sleepycat.je.Database;
import com.sleepycat.je.DatabaseConfig;
import com.sleepycat.je.DatabaseEntry;
import com.sleepycat.je.LockMode;
...
// The key data.
String aKey = "myData";
try {
// Environment open omitted for brevity.
// Open the database that stores your data
DatabaseConfig myDbConfig = new DatabaseConfig();
myDbConfig.setAllowCreate(false);
Database myDatabase = myDbEnv.openDatabase(null, "myDb", myDbConfig);
// Open the database that stores your class information.
Database myClassDb = myDbEnv.openDatabase(null, "classDb", 
myDbConfig); 
// Instantiate the class catalog
StoredClassCatalog classCatalog = new StoredClassCatalog(myClassDb);
// Create the binding
EntryBinding dataBinding = new SerialBinding(classCatalog, 
MyData.class);
// Create DatabaseEntry objects for the key and data
DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));
DatabaseEntry theData = new DatabaseEntry();
// Do the get as normal
myDatabase.get(null, theKey, theData, LockMode.DEFAULT);
// Recreate the MyData object from the retrieved DatabaseEntry using
// the EntryBinding created above
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Bookmarks. Comments, forms and multimedia. Flatten visible layers. C#.NET DLLs: Compress PDF Document. Add necessary references: RasterEdge.Imaging.Basic.dll.
create bookmarks in pdf; bookmarks pdf documents
VB.NET PDF File Split Library: Split, seperate PDF into multiple
Add necessary references: how to split a PDF file into multiple ones by PDF bookmarks or outlines Split PDF Document into Multiple PDF Files Demo Code in VB.NET.
create bookmark in pdf automatically; creating bookmarks pdf files
Library Version 12.1.6.0
Database Records
12/7/2015
Getting Started with JE
Page 94
MyData retrievedData = (MyData) dataBinding.entryToObject(theData);
// Database and environment close omitted for brevity
} catch (Exception e) {
// Exception handling goes here
}
Custom Tuple Bindings
If you want to store complex objects in your database, then you can use tuple bindings to do
this. While they are more work to write and maintain than if you were to use serialization, the
byte array conversion is faster. In addition, custom tuple bindings should allow you to create
byte arrays that are smaller than those created by serialization. Custom tuple bindings also
allow you to optimize your BTree comparisons, whereas serialization does not.
For information on using serialization to store complex objects, see Serializable Complex
Objects (page 89).
To store complex objects using a custom tuple binding:
1. Implement the class whose instances that you want to store. Note that you do not have to
implement the Serializable interface.
2. Write a tuple binding using the com.sleepycat.bind.tuple.TupleBinding class.
3. Open (create) your database. Unlike serialization, you only need one.
4. Create an entry binding that uses the tuple binding that you implemented in step 2.
5. Instantiate an instance of the object that you want to store, and place it in a
DatabaseEntry using the entry binding that you created in the previous step.
For example, suppose you want to your keys to be instances of the following class:
package je.gettingStarted;
public class MyData2 {
private long longData;
private Double doubleData;
private String description;
public MyData2() {
longData = 0;
doubleData = new Double(0.0);
description = "";
}
public void setLong(long data) {
longData = data;
}
public void setDouble(Double data) {
C# PDF File Split Library: Split, seperate PDF into multiple files
Add necessary references: codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines Split PDF Document into Multiple PDF Files in C#.
editing bookmarks in pdf; pdf bookmark
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Compress & decompress PDF document file while maintaining original content of target PDF document file. Remove bookmarks, annotations, watermark, page labels
how to create bookmark in pdf with; excel print to pdf with bookmarks
Library Version 12.1.6.0
Database Records
12/7/2015
Getting Started with JE
Page 95
doubleData = data;
}
public void setString(String data) {
description = data;
}
public long getLong() {
return longData;
}
public Double getDouble() {
return doubleData;
}
public String getString() {
return description;
}
In this case, you need to write a tuple binding for the MyData2 class. When you do this, you
must implement the TupleBinding.objectToEntry() and TupleBinding.entryToObject()
abstract methods. Remember the following as you implement these methods:
• You use TupleBinding.objectToEntry() to convert objects to byte arrays. You use
com.sleepycat.bind.tuple.TupleOutput to write primitive data types to the byte array.
Note that TupleOutput provides methods that allows you to work with numerical types
(long, double, int, and so forth) and not the corresponding java.lang numerical classes.
• The order that you write data to the byte array in TupleBinding.objectToEntry() is the
order that it appears in the array. So given the MyData2 class as an example, if you write
description, doubleData, and then longData, then the resulting byte array will contain
these data elements in that order. This means that your records will sort based on the value
of the description data member and then the doubleData member, and so forth. If you
prefer to sort based on, say, the longData data member, write it to the byte array first.
You use TupleBinding.entryToObject() to convert the byte array back into an instance
of your original class. You use com.sleepycat.bind.tuple.TupleInput to get data from
the byte array.
• The order that you read data from the byte array must be exactly the same as the order in
which it was written.
For example:
package je.gettingStarted;
import com.sleepycat.bind.tuple.TupleBinding;
import com.sleepycat.bind.tuple.TupleInput;
import com.sleepycat.bind.tuple.TupleOutput;
.NET PDF SDK - Description of All PDF Processing Control Feastures
Full page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail display; Insert and add text to any page of PDF document with defined location;
export bookmarks from pdf to excel; how to create bookmarks in pdf file
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
toolkit SDK, preserves all the original anchors, links, bookmarks and font How to Use C#.NET Demo Code to Convert PDF Document to HTML5 Add necessary references
bookmarks pdf file; convert excel to pdf with bookmarks
Library Version 12.1.6.0
Database Records
12/7/2015
Getting Started with JE
Page 96
public class MyTupleBinding extends TupleBinding {
// Write a MyData2 object to a TupleOutput
public void objectToEntry(Object object, TupleOutput to) {
MyData2 myData = (MyData2)object;
// Write the data to the TupleOutput (a DatabaseEntry).
// Order is important. The first data written will be
// the first bytes used by the default comparison routines.
to.writeDouble(myData.getDouble().doubleValue());
to.writeLong(myData.getLong());
to.writeString(myData.getString());
}
// Convert a TupleInput to a MyData2 object
public Object entryToObject(TupleInput ti) {
// Data must be read in the same order that it was
// originally written.
Double theDouble = new Double(ti.readDouble());
long theLong = ti.readLong();
String theString = ti.readString();
MyData2 myData = new MyData2();
myData.setDouble(theDouble);
myData.setLong(theLong);
myData.setString(theString);
return myData;
}
In order to use the tuple binding, instantiate the binding and then use:
• MyTupleBinding.objectToEntry() to convert a MyData2 object to a DatabaseEntry.
• MyTupleBinding.entryToObject() to convert a DatabaseEntry to a MyData2 object.
For example:
package je.gettingStarted;
import com.sleepycat.bind.tuple.TupleBinding;
import com.sleepycat.je.DatabaseEntry;
...
TupleBinding keyBinding = new MyTupleBinding();
MyData2 theKeyData = new MyData2();
How to C#: Basic SDK Concept of XDoc.PDF for .NET
Document Protect. You may add PDF document protection functionality into your C# program. OutLines. This class describes bookmarks in a PDF document.
pdf create bookmarks; how to add bookmarks to pdf files
XDoc.Excel for .NET, Comprehensive .NET Excel Imaging Features
page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail Convert Excel to PDF; Convert Excel to HTML5; Convert Add a blank page or multiple pages to
adding bookmarks to pdf reader; copy pdf bookmarks to another pdf
Library Version 12.1.6.0
Database Records
12/7/2015
Getting Started with JE
Page 97
theKeyData.setLong(123456789l);
theKeyData.setDouble(new Double(12345.6789));
theKeyData.setString("My key data");
DatabaseEntry myKey = new DatabaseEntry();
try {
// Store theKeyData in the DatabaseEntry
keyBinding.objectToEntry(theKeyData, myKey);
...
// Database put and get activity omitted for clarity
...
// Retrieve the key data
theKeyData = (MyData2) keyBinding.entryToObject(myKey);
} catch (Exception e) {
// Exception handling goes here
}
Using Comparators
Internally, JE databases are organized as BTrees. This means that most database operations
(inserts, deletes, reads, and so forth) involve BTree node comparisons. This comparison most
frequently occurs based on database keys, but if your database supports duplicate records
then comparisons can also occur based on the database data.
By default, JE performs all such comparisons using a byte-by-byte lexicographic comparison.
This mechanism works well for most data. However, in some cases you may need to specify
your own comparison routine. One frequent reason for this is to perform a language sensitive
lexical ordering of string keys.
Writing Comparators
You override the default comparison function by providing a Java Comparator class
to the database. The Java Comparator interface requires you to implement the
Comparator.compare() method (see http://java.sun.com/j2se/1.4.2/docs/api/java/util/
Comparator.html for details).
JE passes your Comparator.compare() method the byte arrays that you stored in the
database. If you know how your data is organized in the byte array, then you can write a
comparison routine that directly examines the contents of the arrays. Otherwise, you have to
reconstruct your original objects, and then perform the comparison.
For example, suppose you want to perform unicode lexical comparisons instead of UTF-8 byte-
by-byte comparisons. Then you could provide a comparator that uses String.compareTo(),
which performs a Unicode comparison of two strings (note that for single-byte roman
characters, Unicode comparison and UTF-8 byte-by-byte comparisons are identical – this is
something you would only want to do if you were using multibyte unicode characters with JE).
In this case, your comparator would look like the following:
Library Version 12.1.6.0
Database Records
12/7/2015
Getting Started with JE
Page 98
package je.gettingStarted;
import java.util.Comparator;
public class MyDataComparator implements Comparator {
public MyDataComparator() {}
public int compare(Object d1, Object d2) {
byte[] b1 = (byte[])d1;
byte[] b2 = (byte[])d2;
String s1 = new String(b1, "UTF-8");
String s2 = new String(b2, "UTF-8");
return s1.compareTo(s2);
}
Setting Comparators
You specify a Comparator using the following methods. Note that by default these methods
can only be used at database creation time, and they are ignored for normal database opens.
Also, note that JE uses the no-argument constructor for these comparators. Further, it is not
allowable for there to be a mutable state in these comparators or else unpredictable results
will occur.
• DatabaseConfig.setBtreeComparator()
Sets the Java Comparator class used to compare two keys in the database.
• DatabaseConfig.setDuplicateComparator()
Sets the Java Comparator class used to compare the data on two duplicate records in the
database. This comparator is used only if the database supports duplicate records.
You can use the above methods to set a database's comparator after database creation time
if you explicitly indicate that the comparator is to be overridden. You do this by using the
following methods:
Note
If you override your comparator, the new comparator must preserve the sort order
implemented by your original comparator. That is, the new comparator and the old
comparator must return the same value for the comparison of any two valid objects.
Failure to observe this constraint will cause unpredictable results for your application.
If you want to change the fundamental sort order for your database, back up the
contents of the database, delete the database, recreate it, and then reload its data.
• DatabaseConfig.setOverrideBtreeComparator()
Library Version 12.1.6.0
Database Records
12/7/2015
Getting Started with JE
Page 99
If set to true, causes the database's Btree comparator to be overridden with the
Comparator specified on DatabaseConfig.setBtreeComparator(). This method can be
used to change the comparator post-environment creation.
• DatabaseConfig.setOverrideDuplicateComparator()
If set to true, causes the database's duplicates comparator to be overridden with the
Comparator specified on DatabaseConfig.setDuplicateComparator().
For example, to use the Comparator described in the previous section:
package je.gettingStarted;
import com.sleepycat.je.Database;
import com.sleepycat.je.DatabaseConfig;
import com.sleepycat.je.DatabaseException;
import java.util.Comparator;    
...
// Environment open omitted for brevity
try {
// Get the database configuration object
DatabaseConfig myDbConfig = new DatabaseConfig();
myDbConfig.setAllowCreate(true);
// Set the duplicate comparator class
myDbConfig.setDuplicateComparator(MyDataComparator.class);
// Open the database that you will use to store your data
myDbConfig.setSortedDuplicates(true);
Database myDatabase = myDbEnv.openDatabase(null, "myDb", myDbConfig); 
} catch (DatabaseException dbe) {
// Exception handling goes here
}
Database Record Example
In Database Example (page 77), we created MyDbEnv, a class that manages
DatabaseEnvironment and Database opens and closes. We will now write an application that
takes advantage of this class to open databases, put a series of records in them, and then
close the databases and environment.
Remember that all of the classes and programs presented here can be found in the following
directory:
JE_HOME/examples/je/gettingStarted
Library Version 12.1.6.0
Database Records
12/7/2015
Getting Started with JE
Page 100
where JE_HOME is the location where you placed your JE distribution.
Note that in this example, we are going to save two types of information. First there are
a series of inventory records that identify information about some food items (fruits,
vegetables, and desserts). These records identify particulars about each item such as the
vendor that the item can be obtained from, how much the vendor has in stock, the price per
unit, and so forth.
We also want to manage vendor contact information, such as the vendor's address and phone
number, the sales representative's name and his phone number, and so forth.
Example 8.1. Inventory.java
All Inventory data is encapsulated in an instance of the following class. Note that because
this class is not serializable, we need a custom tuple binding in order to place it on a
DatabaseEntry object. Because the TupleInput and TupleOutput classes used by custom
tuple bindings support Java numerical types and not Java numerical classes, we use int and
float here instead of the corresponding Integer and Float classes.
// File Inventory.java
package je.gettingStarted;
public class Inventory {
private String sku;
private String itemName;
private String category;
private String vendor;
private int vendorInventory;
private float vendorPrice;
public void setSku(String data) {
sku = data;
}
public void setItemName(String data) {
itemName = data;
}
public void setCategory(String data) {
category = data;
}
public void setVendorInventory(int data) {
vendorInventory = data;
}
public void setVendor(String data) {
vendor = data;
}
Library Version 12.1.6.0
Database Records
12/7/2015
Getting Started with JE
Page 101
public void setVendorPrice(float data) {
vendorPrice = data;
}
public String getSku() { return sku; }
public String getItemName() { return itemName; }
public String getCategory() { return category; }
public int getVendorInventory() { return vendorInventory; }
public String getVendor() { return vendor; }
public float getVendorPrice() { return vendorPrice; }
Example 8.2. Vendor.java
The data for vendor records are stored in instances of the following class. Notice that we are
using serialization with this class simply to demonstrate serializing a class instance.
// File Vendor.java
package je.gettingStarted;
import java.io.Serializable;
public class Vendor implements Serializable {
private String repName;
private String address;
private String city;
private String state;
private String zipcode;
private String bizPhoneNumber;
private String repPhoneNumber;
private String vendor;
public void setRepName(String data) {
repName = data;
}
public void setAddress(String data) {
address = data;
}
public void setCity(String data) {
city = data;
}
public void setState(String data) {
state = data;
}
Documents you may be interested
Documents you may be interested