c# web api pdf : Bookmarks in pdf files Library control component .net azure windows mvc BerkeleyDB-JE-GSG5-part702

Library Version 12.1.6.0
Saving and Retrieving Objects
12/7/2015
Getting Started with JE
Page 42
sec2.setSKey("skeyone");
sec3.setPKey("keythree");
sec3.setSKey("skeytwo");
sec4.setPKey("keyfour");
sec4.setSKey("skeythree");
sec5.setPKey("keyfive");
sec5.setSKey("skeyfour");
sda.pIdx.put(sec1);
sda.pIdx.put(sec2);
sda.pIdx.put(sec3);
sda.pIdx.put(sec4);
sda.pIdx.put(sec5);
shutdown();
Finally, to complete our class, we need a main() method, which simply calls our run()
method.
// main
public static void main(String args[]) {
SimpleStorePut ssp = new SimpleStorePut();
try {
ssp.run();
} catch (DatabaseException dbe) {
System.err.println("SimpleStorePut: " + dbe.toString());
dbe.printStackTrace();
} catch (Exception e) {
System.out.println("Exception: " + e.toString());
e.printStackTrace();
}
System.out.println("All done.");
}
Retrieving Objects from an Entity Store
You retrieve objects placed in an entity store by using either the object's primary index, or the
appropriate secondary index if it exists. The following application illustrates this by retrieving
some of the objects that we placed in an entity store in the previous section.
To begin, we import the Java classes that our example needs. We also instantiate the private
data members that we require.
package persist.gettingStarted;
import java.io.File;
Bookmarks in pdf files - 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
adding bookmarks to a pdf; create pdf bookmarks from word
Bookmarks in pdf files - 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
how to bookmark a pdf file; acrobat split pdf bookmark
Library Version 12.1.6.0
Saving and Retrieving Objects
12/7/2015
Getting Started with JE
Page 43
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;
public class SimpleStoreGet {
private static File envHome = new File("./JEDB");
private Environment envmnt;
private EntityStore store;
private SimpleDA sda; 
Next we create a method that simply opens our database environment and entity store for us.
// The setup() method opens the environment and store
// for us.
public void setup()
throws DatabaseException {
EnvironmentConfig envConfig = new EnvironmentConfig();
StoreConfig storeConfig = new StoreConfig();
envConfig.setAllowCreate(true);
storeConfig.setAllowCreate(true);
// Open the environment and entity store
envmnt = new Environment(envHome, envConfig);
store = new EntityStore(envmnt, "EntityStore", storeConfig);
We also need a method to close our environment and store.
// Close our environment and store.
public void shutdown()
throws DatabaseException {
store.close();
envmnt.close();
Now we retrieve a few objects. To do this, we instantiate a SimpleDA (see
SimpleDA.class (page 39)) class that we use to access our primary and secondary indexes.
Then we retrieve objects based on a primary or secondary index value. And finally, we display
the retrieved objects.
// Retrieve some SimpleEntityClass objects from the store.
private void run()
throws DatabaseException {
C# PDF File Split Library: Split, seperate PDF into multiple files
C# codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines. This is an C# example of splitting a PDF to two new PDF files.
how to add bookmark in pdf; copy pdf bookmarks
VB.NET PDF File Split Library: Split, seperate PDF into multiple
VB.NET codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines This is an VB.NET example of splitting a PDF to two new PDF files.
excel print to pdf with bookmarks; bookmarks pdf
Library Version 12.1.6.0
Saving and Retrieving Objects
12/7/2015
Getting Started with JE
Page 44
setup();
// Open the data accessor. This is used to store
// persistent objects.
sda = new SimpleDA(store);
// Instantiate and store some entity classes
SimpleEntityClass sec1 = sda.pIdx.get("keyone");
SimpleEntityClass sec2 = sda.pIdx.get("keytwo");
SimpleEntityClass sec4 = sda.sIdx.get("skeythree");
System.out.println("sec1: " + sec1.getPKey());
System.out.println("sec2: " + sec2.getPKey());
System.out.println("sec4: " + sec4.getPKey());
shutdown();
Finally, to complete our class, we need a main() method, which simply calls our run()
method.
// main
public static void main(String args[]) {
SimpleStoreGet ssg = new SimpleStoreGet();
try {
ssg.run();
} catch (DatabaseException dbe) {
System.err.println("SimpleStoreGet: " + dbe.toString());
dbe.printStackTrace();
} catch (Exception e) {
System.out.println("Exception: " + e.toString());
e.printStackTrace();
}
System.out.println("All done.");
}
Retrieving Multiple Objects
It is possible to iterate over every object referenced by a specific index. You may want to
do this if, for example, you want to examine or modify every object accessible by a specific
primary index.
In addition, some indexes result in the retrieval of multiple objects. For example,
MANY_TO_ONE secondary indexes can result in more than one object for any given key (also
known as duplicate keys). When this is the case, you must iterate over the resulting set of
objects in order to examine each object in turn.
C# PDF File Compress Library: Compress reduce PDF size in C#.net
method, TIFF files compression and decompression method and Image files compression and size, images size reducing can help to reduce PDF file size Bookmarks.
how to add bookmarks on pdf; creating bookmarks in pdf from word
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
converter toolkit SDK, preserves all the original anchors, links, bookmarks and font How to Use C#.NET Demo Code to Convert PDF Document to HTML5 Files in C#
export bookmarks from pdf to excel; how to add bookmark in pdf
Library Version 12.1.6.0
Saving and Retrieving Objects
12/7/2015
Getting Started with JE
Page 45
There are two ways to iterate over a collection of objects as returned by an index. One is to
use a standard Java Iterator, which you obtain using an EntityCursor, which in turn you
can obtain from a PrimaryIndex:
PrimaryIndex<String,SimpleEntityClass> pi =
store.getPrimaryIndex(String.class, SimpleEntityClass.class);
EntityCursor<SimpleEntityClass> pi_cursor = pi.entities();
try {
Iterator<SimpleEntityClass> i = pi_cursor.iterator();
while (i.hasNext()) {
// Do something here
}
} finally {
// Always close the cursor
pi_cursor.close();
Alternatively, you can use a Java "foreach" statement to iterate over object set:
PrimaryIndex<String,SimpleEntityClass> pi =
store.getPrimaryIndex(String.class, SimpleEntityClass.class);
EntityCursor<SimpleEntityClass> pi_cursor = pi.entities();
try {
for (SimpleEntityClass seci : pi_cursor) {
// do something with each object "seci"
}
// Always make sure the cursor is closed when we are done with it.
} finally {
pi_cursor.close();
Cursor Initialization
When a cursor is first opened, it is not positioned to any value; that is, it is not initialized.
Most of the EntityCursor methods that move a cursor will initialize it to either the first or
last object, depending on whether the operation is moving the cursor forward (all next...
methods) or backwards (all prev...) methods.
You can also force a cursor, whether it is initialized or not, to return the first object by
calling EntityCursor.first(). Similarly, you can force a return of the last object using
EntityCursor.last().
Operations that do not move the cursor (such as EntityCursor.current() or
EntityCursor.delete() will throw an IllegalStateException when used on an
uninitialized cursor.
Working with Duplicate Keys
If you have duplicate secondary keys, you can return an EntityIndex class object for them
using SecondaryIndex.subIndex() Then, use that object's entities() method to obtain an
EntityCursor instance.
.NET PDF SDK - Description of All PDF Processing Control Feastures
View,Convert,Edit,Process,Protect,SignPDF Files. in HTML5; Outstanding rendering of PDF documents; Full Outlines, bookmarks, & thumbnail display; Integrated text
split pdf by bookmark; auto bookmark pdf
.NET PDF SDK | Read & Processing PDF files
Simple to convert PDF files to raster images (color or Able to convert PDF documents into other formats extraction of text, hyperlinks, bookmarks and metadata;
export pdf bookmarks; how to create bookmark in pdf with
Library Version 12.1.6.0
Saving and Retrieving Objects
12/7/2015
Getting Started with JE
Page 46
For example:
PrimaryIndex<String,SimpleEntityClass> pi =
store.getPrimaryIndex(String.class, SimpleEntityClass.class);
SecondaryIndex<String,String,SimpleEntityClass> si = 
store.getSecondaryIndex(pi, String.class, "sKey");
EntityCursor<SimpleEntityClass> sec_cursor = 
si.subIndex("skeyone").entities(); 
try {
for (SimpleEntityClass seci : sec_cursor) {
// do something with each object "seci"
}
// Always make sure the cursor is closed when we are done with it.
} finally {
sec_cursor.close(); } 
Note that if you are working with duplicate keys, you can control how cursor iteration works
by using the following EntityCursor methods:
• nextDup()
Moves the cursor to the next object with the same key as the cursor is currently
referencing. That is, this method returns the next duplicate object. If no such object exists,
this method returns null.
• prevDup()
Moves the cursor to the previous object with the same key as the cursor is currently
referencing. That is, this method returns the previous duplicate object in the cursor's set of
objects. If no such object exists, this method returns null.
• nextNoDup()
Moves the cursor to the next object in the cursor's set that has a key which is different than
the key that the cursor is currently referencing. That is, this method skips all duplicate
objects and returns the next non-duplicate object in the cursor's set of objects. If no such
object exists, this method returns null.
• prevNoDup()
Moves the cursor to the previous object in the cursor's set that has a key which is different
than the key that the cursor is currently referencing. That is, this method skips all duplicate
objects and returns the previous non-duplicate object in the cursor's set of objects. If no
such object exists, this method returns null.
For example:
PrimaryIndex<String,SimpleEntityClass> pi =
XDoc.Excel for .NET, Comprehensive .NET Excel Imaging Features
navigation, zooming & rotation; Outlines, bookmarks, & thumbnail Convert Excel to PDF; Convert Excel to HTML5; Combine and merge multiple Excel files; Append Excel
export pdf bookmarks to text; bookmarks pdf reader
XDoc.Word for .NET, Advanced .NET Word Processing Features
page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail Convert Word to PDF; Convert Word to HTML5; combine, and append multiple Word files into one
create bookmarks in pdf reader; how to add bookmarks to pdf document
Library Version 12.1.6.0
Saving and Retrieving Objects
12/7/2015
Getting Started with JE
Page 47
store.getPrimaryIndex(String.class, SimpleEntityClass.class);
SecondaryIndex<String,String,SimpleEntityClass> si = 
store.getSecondaryIndex(pi, String.class, "sKey");
EntityCursor<SimpleEntityClass> sec_cursor = 
si.subIndex("skeyone").entities(); 
try {
SimpleEntityClass sec;
Iterator<SimpleEntityClass> i = sec_cursor.iterator();
while (sec = i.nextNoDup() != null) {
// Do something here
}
// Always make sure the cursor is closed when we are done with it.
} finally {
sec_cursor.close(); } 
Key Ranges
You can restrict the scope of a cursor's movement by specifying a range when you create the
cursor. The cursor can then never be positioned outside of the specified range.
When specifying a range, you indicate whether a range bound is inclusive or exclusive by
providing a boolean value for each range. true indicates that the provided bound is inclusive,
while false indicates that it is exclusive.
You provide this information when you call PrimaryIndex.entities() or
SecondaryIndex.entities(). For example, suppose you had a class indexed by numerical
information. Suppose further that you wanted to examine only those objects with indexed
values of 100 - 199. Then (assuming the numerical information is the primary index), you can
bound your cursor as follows:
EntityCursor<SomeEntityClass> cursor = 
primaryIndex.entities(100, true, 200, false);
try {
for (SomeEntityClass sec : cursor {
// Do something here to objects ranged from 100 to 199
}
// Always make sure the cursor is closed when we are done with it.
} finally {
cursor.close(); } 
Join Cursors
If you have two or more secondary indexes set for an entity object, then you can retrieve sets
of objects based on the intersection of multiple secondary index values. You do this using an
EntityJoin class.
Library Version 12.1.6.0
Saving and Retrieving Objects
12/7/2015
Getting Started with JE
Page 48
For example, suppose you had an entity class that represented automobiles. In that case, you
might be storing information about automobiles such as color, number of doors, fuel mileage,
automobile type, number of passengers, make, model, and year, to name just a few.
If you created a secondary index based this information, then you could use an EntityJoin
to return all those objects representing cars with, say, two doors, that were built in 2002, and
which are green in color.
To create a join cursor, you:
1. Open the primary index for the entity class on which you want to perform the join.
2. Open the secondary indexes that you want to use for the join.
3. Instantiate an EntityJoin object (you use the primary index to do this).
4. Use two or more calls to EntityJoin.addCondition() to identify the secondary indexes
and their values that you want to use for the equality match.
5. Call EntityJoin.entities() to obtain a cursor that you can use to iterate over the join
results.
For example, suppose we had an entity class that included the following features:
package persist.gettingStarted;
import com.sleepycat.persist.model.Entity;
import com.sleepycat.persist.model.PrimaryKey;
import static com.sleepycat.persist.model.Relationship.*;
import com.sleepycat.persist.model.SecondaryKey;
@Entity
public class Automobiles {
// Primary key is the vehicle identification number
@PrimaryKey
private String vin;
// Secondary key is the vehicle's make
@SecondaryKey(relate=MANY_TO_ONE)
private String make;
// Secondary key is the vehicle's color
@SecondaryKey(relate=MANY_TO_ONE)
private String color;
...
public String getVIN() {
return vin;
}
Library Version 12.1.6.0
Saving and Retrieving Objects
12/7/2015
Getting Started with JE
Page 49
public String getMake() {
return make;
}
public String getColor() {
return color;
}
... 
Then we could perform an entity join that searches for all the red automobiles made by
Toyota as follows:
PrimaryIndex<String,Automobiles> vin_pidx;
SecondaryIndex<String,String,Automobiles> make_sidx;
SecondaryIndex<String,String,Automobiles> color_sidx;
EntityJoin<String,Automobiles> join = new EntityJoin(vin_pidx);
join.addCondition(make_sidx,"Toyota");
join.addCondition(color_sidx,"Red");
// Now iterate over the results of the join operation
ForwardCursor<Automobiles> join_cursor = join.entities();
try {
for (Automobiles autoi : join_cursor) {
// do something with each object "autoi"
}
// Always make sure the cursor is closed when we are done with it.
} finally {
join_cursor.close();
Deleting Entity Objects
The simplest way to remove an object from your entity store is to delete it by its primary
index. For example, using the SimpleDA class that we created earlier in this document (see
SimpleDA.class (page 39)), you can delete the SimpleEntityClass object with a primary
key of keyone as follows:
sda.pIdx.delete("keyone");
You can also delete objects by their secondary keys. When you do this, all objects related to
the secondary key are deleted, unless the key is a foreign object.
For example, the following deletes all SimpleEntityClass with a secondary key of skeyone:
sda.sIdx.delete("skeyone");
You can delete any single object by positioning a cursor to that object and then calling the
cursor's delete() method.
Library Version 12.1.6.0
Saving and Retrieving Objects
12/7/2015
Getting Started with JE
Page 50
PrimaryIndex<String,SimpleEntityClass> pi =
store.getPrimaryIndex(String.class, SimpleEntityClass.class);
SecondaryIndex<String,String,SimpleEntityClass> si = 
store.getSecondaryIndex(pi, String.class, "sKey");
EntityCursor<SimpleEntityClass> sec_cursor = 
si.subIndex("skeyone").entities(); 
try {
SimpleEntityClass sec;
Iterator<SimpleEntityClass> i = sec_cursor.iterator();
while (sec = i.nextDup() != null) {
if (sec.getSKey() == "some value") {
i.delete();
}
}
// Always make sure the cursor is closed when we are done with it.
} finally {
sec_cursor.close(); } 
Finally, if you are indexing by foreign key, then the results of deleting the key is
determined by the foreign key constraint that you have set for the index. See Foreign Key
Constraints (page 36) for more information.
Replacing Entity Objects
To modify a stored entity object, retrieve it, update it, then put it back to the entity store:
SimpleEntityClass sec = sda.pIdx.get("keyone");
sec.setSKey("skeyoneupdated");
sda.pIdx.put(sec);
Note that because we updated a field on the object that is a secondary key, this object will
now be accessible by the secondary key of skeyoneupdated instead of the previous value,
which was skeyone
Be aware that if you modify the object's primary key, the behavior is somewhat different.
In this case, you cause a new instance of the object to be created in the store, instead of
replacing an existing instance:
// Results in two objects in the store.  One with a
// primary index of "keyfive" and the other with primary index of 
//'keyfivenew'.
SimpleEntityClass sec = sda.pIdx.get("keyfive");
sec.setPKey("keyfivenew");
sda.pIdx.put(sec); 
Finally, if you are iterating over a collection of objects using an EntityCursor, you can
update each object in turn using EntityCursor.update(). Note, however, that you
Library Version 12.1.6.0
Saving and Retrieving Objects
12/7/2015
Getting Started with JE
Page 51
must be iterating using a PrimaryIndex; this operation is not allowed if you are using a
SecondaryIndex.
For example, the following iterates over every SimpleEntityClass object in the entity store,
and it changes them all so that they have a secondary index of updatedskey:
EntityCursor<SimpleEntityClass> sec_pcursor = sda.pIdx.entities();
for (SimpleEntityClass sec : sec_pcursor) {
sec.setSKey("updatedskey");
sec_pcursor.update(item);
}
sec_pcursor.close(); 
Documents you may be interested
Documents you may be interested