This package consists of classes that provides the core abstractions for
a content store. A content store uses a JUMPStore to persist the
content store data.
The following sample code shows, how a store can be implemented on a
filesystem. Every node that does not contain JUMPData is
represented as a directory in the filesystem and every data node is
represented in a single file say data.properties. Each line in the
data.properties file contains the following information.
data-name,data-type,data-value
public class FileStoreImpl implements JUMPStore {
public void createDataNode(String uri, JUMPData jumpData) {
// get the full path of the file that holds the data for the
// uri passed.
File file = uriToDataFile(uri);
// the data name is the last component of the URI.
String dataName = getDataName(uri);
String marshalledData = createMarshalledData(dataName, jumpData);
OutputStream stream = createOutputStream(file);
stream.writeString(marshalled);
// The impl might create an instance of JUMPNode containing the jumpData
// eagerly here, or delay until it is requested by getNode(String uri)
// call below.
}
public void createNode(String uri) {
File file = uriToFile(uri);
file.mkdirs();
}
public JUMPNode getNode(String uri) {
// getNode(String) needs to return what the createDataNode() above store
// if the uri parameter represents a data node.
if (!isDataFile(uri)) {
// This URI represents non-leaf node.
// .... then do something to create a JUMPNode representing a List,
// and return it.
} else {
File file = urlToDataFile(uri);
String name = getDataName(uri);
InputStream stream = createInputStream(file);
String marshalledData = stream.readString();
JUMPData data = createUnmarshalledData(marshalledData);
JUMPNode node = createJUMPNode(uri, name, data);
return node;
}
}
public void deleteNode(String uri) {
File file = uriToFile(uri);
file.delete();
}
public void updateNode(String uri, JUMPData jumpData) {
// check if the node represented by the uri exists and is data.
if (!isDataFile(uri) || !exists(uri) ) {
throw new java.io.IOException("Update failed");
}
// delete the old node and create a node with the new data.
deleteNode(uri);
createDataNode(uri, jumpData);
}
private String createMarshalledData(String dataname, JUMPData data) {
// Create a representation of JUMPData's content to be written out to the file.
// This method does not have to process anything in JUMPData data, but merely to
// come up with a String representation of the JUMPData content that works the
// opposite way of createUnmarshalledData. The returned type, String, is also
// just for the implementation example, and can also be in any other format.
}
private JUMPData createUnmarshalledData(String marshalledData) {
// Creates a JUMPData out of the "marshalledData" representation.
// This method should just do the opposite of createMarshalledData(JUMPData).
}
}
The following sample code shows how a concrete content store can be implemented
by extending the JUMPContentStore. The object that the sample
stores in the content store is Application which consists of
a title and a iconPath. AppRepository has methods to get
the Application objects.
public class Application {
public String getTitle() {
return title;
}
public String getIconPath() {
return iconPath;
}
}
public class AppRepository extends JUMPContentStore {
private static final String ROOT_URI = "./Apps";
private Class storeClass = JUMPFileStore.class;
protected JUMPStore getStore() {
return JUMPExecutive.getInstance().getModule(this.storeClass);
}
public Application getApplication(String name) {
Application app = new Application();
// get access to the store in a read-only mode
JUMPStoreHandle storeHandle = openStore(false);
JUMPNode.Data appNode = (JUMPNode.Data)
storeHandle.getNode(ROOT_URI+"/"+name+"/title");
app.setTitle(appNode.getString());
appNode = (JUMPNode.Data)
storeHandle.getNode(ROOT_URI+"/"+name+"/iconPath");
app.setIconPath(appNode.getString());
// indicate that we do not need the store any more
closeStore(storeHandle);
return app;
}
}
|