Public

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

<init>

getFailedObject

getMessage

Point

Finding current android device location

An interface for an object which represents a database table entry, returned as
the result of the qu

java.sql.ResultSet

Doubly-linked list implementation of the List and Dequeinterfaces. Implements
all optional list oper

java.util.LinkedList

SortedSet is a Set which iterates over its elements in a sorted order. The order
is determined eithe

java.util.SortedSet

javax.imageio.ImageIO

Central representation of an Ant project. This class defines an Ant project with
all of its targets,

org.apache.tools.ant.Project

Encapsulate an XML parse error or warning.> This module, both source code and documentation, is in t

org.xml.sax.SAXParseException

getSupportFragmentManager

requestLocationUpdates

getExternalFilesDir

/**
     * 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