c# web api pdf : How to bookmark a pdf document application Library cloud windows asp.net html class BerkeleyDB-JE-GSG3-part700

Library Version 12.1.6.0
Database Environments
12/7/2015
Getting Started with JE
Page 22
envConfig.setAllowCreate(true);
envConfig.setTransactional(true);
myDatabaseEnvironment = 
new Environment(new File("/export/dbEnv"), envConfig);
} catch (DatabaseException dbe) {
System.err.println(dbe.toString());
System.exit(1);
EnvironmentMutableConfig
EnvironmentMutableConfig manages properties that can be reset after the
Environment object has been constructed. In addition, EnvironmentConfig extends
EnvironmentMutableConfig, so you can set these mutable properties at Environment
construction time if necessary.
The EnvironmentMutableConfig class allows you to set the following properties:
• setCachePercent()
Determines the percentage of JVM memory available to the JE cache. See Sizing the
Cache (page 159) for more information.
setCacheSize()
Determines the total amount of memory available to the database cache. See Sizing the
Cache (page 159) for more information.
• setTxnNoSync()
Determines whether change records created due to a transaction commit are written to the
backing log files on disk. A value of true causes the data to not be flushed to disk. See the
Berkeley DB, Java Edition Getting Started with Transaction Processing guide.
• setTxnWriteNoSync()
Determines whether logs are flushed on transaction commit (the logs are still written,
however). By setting this value to true, you potentially gain better performance than if
you flush the logs on commit, but you do so by losing some of your transaction durability
guarantees.
There is also a corresponding getter method (getTxnNoSync()). Moreover, you can
always retrieve your environment's EnvironmentMutableConfig object by using the
Environment.getMutableConfig() method.
For example:
package je.gettingStarted;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
How to bookmark a 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
bookmarks in pdf files; how to create bookmarks in pdf file
How to bookmark a 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
bookmark template pdf; creating bookmarks in pdf files
Library Version 12.1.6.0
Database Environments
12/7/2015
Getting Started with JE
Page 23
import com.sleepycat.je.EnvironmentMutableConfig;
import java.io.File;
...
try {
Environment myEnv = new Environment(new File("/export/dbEnv"), null);
EnvironmentMutableConfig envMutableConfig = 
new EnvironmentMutableConfig();
envMutableConfig.setTxnNoSync(true);
myEnv.setMutableConfig(envMutableConfig); 
} catch (DatabaseException dbe) {
// Exception handling goes here
Environment Statistics
JE offers a wealth of information that you can examine regarding your environment's
operations. The majority of this information involves numbers relevant only to the JE
developer and as such a description of those statistics is beyond the scope of this manual.
However, one statistic that is very important (especially for long-running applications) is
EnvironmentStats.getNCacheMiss(). This statistic returns the total number of requests for
database objects that were not serviceable from the cache. This number is important to the
application administrator who is attempting to determine the proper size for the in-memory
cache. See Sizing the Cache (page 159) for details.
To obtain this statistic from your environment, call Environment.getStats() to return an
EnvironmentStats object. You can then call the EnvironmentStats.getNCacheMiss()
method. For example:
import com.sleepycat.je.Environment;
...
long cacheMisses = myEnv.getStats(null).getNCacheMiss();
...  
Note that Environment.getStats() can only obtain statistics from your application's process.
In order for the application administrator to obtain this statistic, you must either use JMX
to retrieve the statistic (see JConsole and JMX Support (page 11)) or you must print it for
examination (for example, log the value once a minute).
Remember that what is really important for cache sizing is the change in this value over time,
and not the actual value itself. So you might consider offering a delta from one examination
of this statistic to the next (a delta of 0 is desired while large deltas are an indication that the
cache is too small).
C# PDF Converter Library SDK to convert PDF to other file formats
NET. How to Use C#.NET XDoc.PDF Component to Convert PDF Document to Various Document and Image Forms in Visual C# .NET Application.
add bookmarks to pdf preview; add bookmarks pdf
VB.NET PDF File Split Library: Split, seperate PDF into multiple
Split PDF document by PDF bookmark and outlines in VB.NET. Independent component for splitting PDF document in preview without using external PDF control.
bookmarks in pdf reader; convert word to pdf with bookmarks
Library Version 12.1.6.0
Database Environments
12/7/2015
Getting Started with JE
Page 24
Database Environment Management Example
This example provides a complete class that can open and close an environment. It is both
extended and used in subsequent examples in this book to open and close both environments
and databases. We do this so as to make the example code shorter and easier to manage. You
can find this class in:
JE_HOME/examples/je/gettingStarted/MyDbEnv.java
where JE_HOME is the location where you placed your JE distribution.
Example 2.1. Database Environment Management Class
First we write the normal class declarations. We also set up some private data members that
are used to manage environment creation. We use the class constructor to instantiate the
EnvironmentConfig object that is used to configure our environment when we open it.
// File MyDbEnv.java
package je.gettingStarted;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;
import java.io.File;
public class MyDbEnv {
private Environment myEnv;
public MyDbEnv() {} 
Next we need a method to open the environment. This is responsible for instantiating our
Environment object. Remember that instantiation is what opens the environment (or creates
it if the creation property is set to true and the environment does not currently exist).
public void setup(File envHome, boolean readOnly) 
throws DatabaseException {
// Instantiate an environment configuration object
EnvironmentConfig myEnvConfig = new EnvironmentConfig();
// Configure the environment for the read-only state as identified
// by the readOnly parameter on this method call.
myEnvConfig.setReadOnly(readOnly);
// If the environment is opened for write, then we want to be 
// able to create the environment if it does not exist.
myEnvConfig.setAllowCreate(!readOnly);
// Instantiate the Environment. This opens it and also possibly
// creates it.
C# PDF Library SDK to view, edit, convert, process PDF file for C#
RasterEdge PDF SDK for .NET package offers robust APIs for editing PDF document hyperlink (url) and quick navigation link in PDF bookmark.
bookmark page in pdf; add bookmark pdf file
VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
PDF. Image: Remove Image from PDF Page. Image Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit Document Protect. Password: Set File Permissions. Password:
bookmarks in pdf from word; how to bookmark a pdf document
Library Version 12.1.6.0
Database Environments
12/7/2015
Getting Started with JE
Page 25
myEnv = new Environment(envHome, myEnvConfig);
Next we provide a getter method that allows us to retrieve the Environment directly. This is
needed for later examples in this guide.
// Getter methods
public Environment getEnv() {
return myEnv;
Finally, we need a method to close our Environment. We wrap this operation in a try block so
that it can be used gracefully in a finally statement.
// Close the environment
public void close() {
if (myEnv != null) {
try {
myEnv.close();
} catch(DatabaseException dbe) {
System.err.println("Error closing environment" + 
dbe.toString());
}
}
}
This completes the MyDbEnv class. While not particularly useful as it currently exists, we will
build upon it throughout this book so that it will eventually open and close all of the entity
stores or databases required by our applications.
We can now use MyDbEnv to open and close a database environment from the appropriate
place in our application. For example:
package je.gettingStarted;
import com.sleepycat.je.DatabaseEntry;
import com.sleepycat.je.DatabaseException;
import java.io.File;
...
MyDbEnv exampleDbEnv = new MyDbEnv();
try {    
exampleDbEnv.setup(new File("/directory/currently/exists"), true);
...
} catch(DatabaseException dbe) {
// Error code goes here
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
watermark and save PDF text, image, table, hyperlink and bookmark to Word library control (XDoc.PDF) is a mature and effective PDF document converting utility.
pdf bookmark editor; create bookmark pdf
How to C#: Basic SDK Concept of XDoc.PDF for .NET
XDoc.PDF for .NET allows C# developers to edit hyperlink of PDF document, including editing PDF url links and quick navigation link in bookmark/outline.
adding bookmarks to pdf document; export pdf bookmarks
Library Version 12.1.6.0
Database Environments
12/7/2015
Getting Started with JE
Page 26
} finally {
exampleDbEnv.close();
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
Change Word hyperlink to PDF hyperlink and bookmark. DOCXDocument doc = new DOCXDocument(inputFilePath); // Convert it to PDF document.
create bookmarks pdf; export excel to pdf with bookmarks
C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net
C#.NET Program. Free PDF document processing SDK supports PDF page extraction, copying and pasting in Visual Studio .NET project.
add bookmark pdf; create bookmarks in pdf
Part I. Programming with
the Direct Persistence Layer
This section discusses how to build an application using the DPL. The DPL is ideally suited for those
applications that want a mechanism for storing and managing Java class objects in a JE database. Note
that the DPL is best suited for applications that work with classes with a relatively static schema.
The DPL requires Java 1.5.
If you are porting an application from the Berkeley DB API, then you probably want to use the base API
instead of the DPL. For information on using the base API, see Programming with the Base API (page
68).
12/7/2015
Getting Started with JE
Page 28
Chapter 3. Direct Persistence Layer First Steps
This chapter guides you through the first few steps required to use the DPL with your
application. These steps include:
1. Opening your environment as was described in Opening Database Environments (page 16).
2. Opening your entity store.
3. Identifying the classes that you want to store in JE as either a persistent class or an
entity.
Once you have done these things, you can write your classes to the JE databases, read them
back from the databases, delete them from the databases, and so forth. These activities are
described in the chapters that follow in this part of this manual.
Entity Stores
Entity stores are the basic unit of storage that you use with the DPL. That is, it is a unit of
encapsulation for the classes that you want to store in JE. Under the hood it actually interacts
with JE databases, but the DPL provides a layer of abstraction from the underlying JE APIs.
The store, therefore, provides a simplified mechanism by which you read and write your
stored classes. By using a store, you have access to your classes that is more simplified than if
you were interacting with databases directly, but this simplified access comes at the cost of
reduced flexibility.
Entity stores have configurations in the same way that environments have configurations. You
can use a StoreConfig object to identify store properties. Among these are methods that
allow you to declare whether:
• the store can be created if it does not exist at the time it is opened. Use the
StoreConfig.setAllowCreate() method to set this.
• deferred writes are allowed for the store. Use the StoreConfig.setDeferredWrite()
method to set this. See Deferred Write Databases (page 70) for general information on
deferred write databases.
• the store is read-only. Use the StoreConfig.setReadOnly() method to set this.
• the store supports transactions. Use the StoreConfig.setTransactional() method to set
this.
Writing JE transactional applications is described in the Berkeley DB, Java Edition Getting
Started with Transaction Processing guide.
EntityStore objects also provide methods for retrieving information about the store, such
as:
• the store's name. Use the EntityStore.getStoreName() method to retrieve this.
Library Version 12.1.6.0
Direct Persistence Layer First Steps
12/7/2015
Getting Started with JE
Page 29
• a handle to the environment in which the store is opened. Use the
EntityStore.getEnvironment method to retrieve this handle.
You can also use the EntityStore to retrieve all the primary and secondary indexes related to
a given type of entity object contained in the store. See Working with Indices (page 33) for
more information.
Opening and Closing Environments and Stores
As described in Database Environments (page 16), an environment is a unit of encapsulation
for JE databases. It also provides a handle by which activities common across the databases
can be managed.
To use an entity store, you must first open an environment and then provide that environment
handle to the EntityStore constructor.
For example, the following code fragment configures both the environment and the entity
store such that they can be created if they do not exist. Both the environment and the entity
store are then opened.
package persist.gettingStarted;
import java.io.File;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;
import com.sleepycat.persist.EntityStore;
import com.sleepycat.persist.StoreConfig;
...
private Environment myEnv;
private EntityStore store;
try {
EnvironmentConfig myEnvConfig = new EnvironmentConfig();
StoreConfig storeConfig = new StoreConfig();
myEnvConfig.setAllowCreate(!readOnly);
storeConfig.setAllowCreate(!readOnly);
// Open the environment and entity store
myEnv = new Environment(envHome, myEnvConfig);
store = new EntityStore(myEnv, "EntityStore", storeConfig);
} catch(DatabaseException dbe) {
System.err.println("Error opening environment and store: " +
dbe.toString());
System.exit(-1);
Library Version 12.1.6.0
Direct Persistence Layer First Steps
12/7/2015
Getting Started with JE
Page 30
As always, before you exit your program you should close both your store and your
environment. It is recommended that you close your store before you close your environment.
if (store != null) {
try {
store.close();
} catch(DatabaseException dbe) {
System.err.println("Error closing store: " +
dbe.toString());
System.exit(-1);
}
}
if (myEnv != null) {
try {
// Finally, close environment.
myEnv.close();
} catch(DatabaseException dbe) {
System.err.println("Error closing MyDbEnv: " +
dbe.toString());
System.exit(-1);
}
Persistent Objects
When using the DPL, you store data in the underlying JE databases by making objects
persistent. You do this using Java annotations that both identify the type of persistent object
you are declaring, as well as the primary and secondary indices.
The following are the annotations you will use with your DPL persistent classes:
Annotation
Description
@Entity
Declares an entity class; that is, a class with
a primary index and optionally one or more
indices.
@Persistent
Declares a persistent class; that is, a class
used by an entity class. They do not have
indices but instead are are stored or retrieved
when an entity class makes direct use of
them.
@PrimaryKey
Declares a specific data member in an entity
class to be the primary key for that object.
This annotation must be used one and only
one time for every entity class.
@SecondaryKey
Declares a specific data member in an entity
class to be a secondary key for that object.
This annotation is optional, and can be used
multiple times for an entity class.
Library Version 12.1.6.0
Direct Persistence Layer First Steps
12/7/2015
Getting Started with JE
Page 31
For example, the following is declared to be an entity class:
package persist.gettingStarted;
import com.sleepycat.persist.model.Entity;
import com.sleepycat.persist.model.PrimaryKey;
@Entity
public class ExampleEntity {
// The primary key must be unique in the database.
@PrimaryKey
private String aPrimaryKey;
@SecondaryKey(relate=MANY_TO_ONE)
private String aSecondaryKey;
...
// The remainder of the class' implementation is purposefully
// omitted in the interest of brevity.
...
We discuss primary and secondary keys in more detail in Working with Indices (page 33).
Saving and Retrieving Data
All data stored using the DPL has one primary index and zero or more secondary indices
associated with it. (Sometimes these are referred to as the primary and secondary keys.) So to
store data under the DPL, you must:
1. Declare a class to be an entity class.
2. Identify the features on the class which represent indexed material.
3. Retrieve the store's primary index for a given class using the
EntityStore.getPrimaryIndex() method.
4. Put class objects to the store using the PrimaryIndex.put() method.
In order to retrieve an object from the store, you use the index that is most convenient for
your purpose. This may be the primary index, or it may be some other secondary index that
you declared on your entity class.
You obtain a primary index in the same was as when you put the object to the store: using
EntityStore.getPrimaryIndex(). You can get a secondary index for the store using the
EntityStore.getSecondaryIndex() method. Note that getSecondaryIndex() requires you
to provide a PrimaryIndex class instance when you call it, so a class's primary index is always
required when retrieving objects from an entity store.
Documents you may be interested
Documents you may be interested