Public

Constructs a new JDOObjectNotFoundException with the specified detail message,
nested Throwables, an

<init>

getFailedObject

getMessage

Point

Creating JSON documents from java classes using gson

java.awt.Menu

An input stream that reads bytes from a file.    
File file = ...finally  
if (in != null)  
in.clos

java.io.FileInputStream

Wraps either an existing OutputStream or an existing Writerand provides
convenience methods for prin

java.io.PrintWriter

A specific moment in time, with millisecond precision. Values typically come
from System#currentTime

java.util.Date

UUID is an immutable representation of a 128-bit universally unique identifier
(UUID). There are mul

java.util.UUID

org.hamcrest.core.IsNull

setScale

startActivity

findViewById

/**
     * Accessor for an object given the object id. Checks the inheritance level of the object
     * @param id Id of the object.
     * @param fv Field values for the object
     * @return The Object
     */

// className is null when id class exists, and object has been

// not found in cache, will get a Hollow instance

/**
     * Method performing the retrieval of the record from the datastore. Takes
     * the constructed retrieval query and populates with the specific record
     * information.
     *
     * @param sm The state manager for the record to be retrieved
     **/

// application identity - provide primary key fields

/**
     * Convenience method to update the contents of a BLOB column.
     * Oracle requires that a BLOB is initialised with EMPTY_BLOB() and then you retrieve
     * the column and update its BLOB value. Performs a statement
     * <pre>
     * SELECT {blobColumn} FROM TABLE WHERE ID=? FOR UPDATE
     * </pre>
     * and then updates the Blob value returned.
     * @param sm StateManager of the object
     * @param datastoreContainer Table storing the BLOB column
     * @param mapping Datastore mapping for the BLOB column
     * @param bytes The bytes to store in the BLOB
     * @throws JDOObjectNotFoundException
     * @throws JDODataStoreException
     */

// Generate "SELECT {blobColumn} FROM TABLE WHERE ID=? FOR UPDATE" statement

// Oracle JDBC drivers version 9 and below use some sh*tty Oracle-specific BLOB type

// we have to cast to that, face west, pray whilst saying ommmmmmmmmmm

// Oracle JDBC drivers 10 and above supposedly use the JDBC standard class for Blobs

/**
     * Convenience method to update the contents of a CLOB column.
     * Oracle requires that a CLOB is initialised with EMPTY_CLOB() and then you retrieve
     * the column and update its CLOB value. Performs a statement
     * <pre>
     * SELECT {clobColumn} FROM TABLE WHERE ID=? FOR UPDATE
     * </pre>
     * and then updates the Clob value returned.
     * @param sm StateManager of the object
     * @param datastoreContainer Table storing the CLOB column
     * @param mapping Datastore mapping for the CLOB column
     * @param value The value to store in the CLOB
     * @throws JDOObjectNotFoundException
     * @throws JDODataStoreException
     */

// Generate "SELECT {clobColumn} FROM TABLE WHERE ID=? FOR UPDATE" statement

// Oracle JDBC drivers version 9 and below use some sh*tty Oracle-specific CLOB type

// Oracle JDBC drivers 10 and above supposedly use the JDBC standard class for Clobs

// Debug information about what we are retrieving

// Execute any mapping actions now that we have fetched the element

/**
     * Look to the database to determine which
     * class this object is. This parameter is a hint. Set false, if it's
     * already determined the correct pcClass for this pc "object" in a certain
     * level in the hierarchy. Set to true and it will look to the database.
     * @param fv the initial field values of the object.
     */

// Inheritance case, check the level of the instance

// className is null when id class exists, and object has been validated and doesn't exist.

//load the class and make sure the class is initialized

"StateManager.GetObjectByIdClassNotFound"

"This constructor is only for objects using application identity."

// Note that this will mean the fields are loaded twice (loaded earlier in this method)

// and also that postLoad will be called twice

/**
     * Accessor for an object given the object id. If validate is false, we return the object
     * if found in the cache, or otherwise a Hollow object with that id. If validate is true
     * we check with the datastore and return an object with the FetchPlan fields loaded (unless
     * the object doesnt exist in the datastore, where we throw an ObjectNotFoundException).
     * @param id Id of the object.
     * @param validate Whether to validate the object state
     * @param checkInheritance Whether look to the database to determine which
     * class this object is.
     * @param objectClassName Class name for the object with this id (if known, optional)
     * @return The Object with this id
     */

// Object not found in cache(s) with this identity

// OID, so check that the implied class is managed

// SingleFieldIdentity, so check that the implied class is managed

// Object class name specified so use that directly

// We dont know the object class so try to deduce it from what is known by the StoreManager

// Verify if correct class inheritance level is set

// We just checked the name of the class in the section above so just use that

// Inheritance checking has found a different inherited

// object with this identity so create new id

// Create new OID using correct target class

// try again to read object from cache with this id

// Create new SingleFieldIdentity using correct targetClass

// Object not found in Cache even after inheritance updates so create a Hollow instance

// User requests validation of the instance so go to the datastore to validate it

// loading any fetchplan fields that are needed in the process.

// Cache the object (update it if already present)

/**
     * Convenience method to convert an exception into a JDO exception.
     * If the incoming exception has a "failed object" then create the new exception with
     * a failed object. Otherwise if the incoming exception has nested exceptions then
     * create this exception with those nested exceptions. Else create this exception with
     * the incoming exception as its nested exception.
     * @param ne NucleusException
     * @return The JDOException
     */

// No JDOReadOnlyException so JDO1.0-JDO2.1

//sadly JDOFatalDataStoreException dont allow nested exceptions and failed objects together

How to use javax.jdo.JDOObjectNotFoundExceptionconstructor

Best Java code snippets using javax.jdo.JDOObjectNotFoundException.<init> (Showing top 9 results out of 315)

How to use
javax.jdo.JDOObjectNotFoundException
constructor