Lines Matching defs:handle
181 * the objects to handle any versioning that occurs.
209 /** handle value representing null */
212 /** marker for unshared objects in internal handle table */
249 /** wire handle -> obj/exception map */
251 /** scratch field for passing handle values up/down call stack */
367 // if nested read, passHandle contains handle of enclosing object
423 * to deserialize back-references to the stream handle deserialized
426 * Deserializing an object via readUnshared invalidates the stream handle
457 // if nested read, passHandle contains handle of enclosing object
1387 * replacement for object, and updates handle table accordingly. Returns
1389 * occurred. Expects that passHandle is set to given object's handle prior
1443 * Reads in object handle, sets passHandle to the read handle, and returns
1444 * object associated with the handle.
1453 String.format("invalid handle value: %08X", passHandle +
1473 * assigned handle. Returns null if class is unresolvable (in which case a
1474 * ClassNotFoundException will be associated with the class' handle in the
1475 * handle table).
1496 * to class descriptor's assigned handle. If class descriptor cannot be
1498 * associated with the class descriptor's handle.
1531 * passHandle to proxy class descriptor's assigned handle. If proxy class
1533 * ClassNotFoundException is associated with the descriptor's handle.
1582 * proxy class. Sets passHandle to class descriptor's assigned handle. If
1584 * ClassNotFoundException is associated with the descriptor's handle.
1629 * assigned handle.
1654 * unresolvable. Sets passHandle to array's assigned handle.
1716 * unresolvable. Sets passHandle to enum constant's assigned handle.
1759 * associated with object's handle). Sets passHandle to object's assigned
1760 * handle.
1820 * Expects that passHandle is set to obj's handle before this method is
1838 * In most cases, the handle table has already propagated
1871 * is set to obj's handle before this method is called.
1894 * In most cases, the handle table has already
1963 * passHandle is set to obj's handle before this method is called.
2003 * passHandle to fatal exception's handle.
3150 * data mode to handle UTF-encoded characters which (potentially)
3207 * Unsynchronized table which tracks wire handle to object mappings, as
3215 * given object is first assigned a handle by calling the assign method.
3216 * This method leaves the assigned handle in an "open" state, wherein
3219 * associated with the handle by calling markException. When a handle is
3224 * <p>Once all exception information/dependencies for the handle have been
3225 * registered, the handle should be "closed" by calling the finish method
3226 * on it. The act of finishing a handle allows the exception propagation
3242 /** array mapping handle -> object status */
3244 /** array mapping handle -> object/exception (depending on status) */
3246 /** array mapping handle -> list of dependent handles (if any) */
3254 * Creates handle table with the given initial capacity.
3263 * Assigns next available handle to given object, and returns assigned
3264 * handle. Once object has been completely deserialized (and all
3265 * dependencies on other objects identified), the handle should be
3278 * Registers a dependency (in exception status) of one handle on
3279 * another. The dependent handle must be "open" (i.e., assigned, but
3281 * handle is NULL_HANDLE.
3329 * with the currently active handle and propagates it to other
3330 * referencing objects as appropriate. The specified handle must be
3333 void markException(int handle, ClassNotFoundException ex) {
3334 switch (status[handle]) {
3336 status[handle] = STATUS_EXCEPTION;
3337 entries[handle] = ex;
3340 HandleList dlist = deps[handle];
3346 deps[handle] = null;
3359 * Marks given handle as finished, meaning that no new dependencies
3360 * will be marked for handle. Calls to the assign and finish methods
3363 void finish(int handle) {
3366 // no pending unknowns, only resolve current handle
3367 end = handle + 1;
3368 } else if (lowDep >= handle) {
3378 for (int i = handle; i < end; i++) {
3396 * Assigns a new object to the given handle. The object previously
3397 * associated with the handle is forgotten. This method has no effect
3398 * if the given handle already has an exception associated with it.
3399 * This method may be called at any time after the handle is assigned.
3401 void setObject(int handle, Object obj) {
3402 switch (status[handle]) {
3405 entries[handle] = obj;
3417 * Looks up and returns object associated with the given handle.
3418 * Returns null if the given handle is NULL_HANDLE, or if it has an
3421 Object lookupObject(int handle) {
3422 return (handle != NULL_HANDLE &&
3423 status[handle] != STATUS_EXCEPTION) ?
3424 entries[handle] : null;
3429 * given handle. Returns null if the given handle is NULL_HANDLE, or
3430 * if there is no ClassNotFoundException associated with the handle.
3432 ClassNotFoundException lookupException(int handle) {
3433 return (handle != NULL_HANDLE &&
3434 status[handle] == STATUS_EXCEPTION) ?
3435 (ClassNotFoundException) entries[handle] : null;
3485 public void add(int handle) {
3491 list[size++] = handle;