/** * These methods must be provided by a derived class. They are responsible * for packing and unpacking an object's state to/from a state buffer. * StateManager calls them at appropriate times during the lifetime of the * object, and may then pass the buffer to a persistent object store for * saving. * * @return <code>true</code> on success, <code>false</code> otherwise. */ public synchronized boolean restore_state (InputObjectState os, int ot) { if (ot == ObjectType.ANDPERSISTENT) { try { unpackHeader(os, new Header()); } catch (IOException e) { return false; } } return true; }
/** * These methods must be provided by a derived class. They are responsible * for packing and unpacking an object's state to/from a state buffer. * StateManager calls them at appropriate times during the lifetime of the * object, and may then pass the buffer to a persistent object store for * saving. * * @return <code>true</code> on success, <code>false</code> otherwise. */ public synchronized boolean restore_state (InputObjectState os, int ot) { if (ot == ObjectType.ANDPERSISTENT) { try { unpackHeader(os, new Header()); } catch (IOException e) { return false; } } return true; }
/** * These methods must be provided by a derived class. They are responsible * for packing and unpacking an object's state to/from a state buffer. * StateManager calls them at appropriate times during the lifetime of the * object, and may then pass the buffer to a persistent object store for * saving. * * @return <code>true</code> on success, <code>false</code> otherwise. */ public boolean restore_state (InputObjectState os, int ot) { if (ot == ObjectType.ANDPERSISTENT) { try { unpackHeader(os, new Header()); } catch (IOException e) { return false; } } return true; }
/** * These methods must be provided by a derived class. They are responsible * for packing and unpacking an object's state to/from a state buffer. * StateManager calls them at appropriate times during the lifetime of the * object, and may then pass the buffer to a persistent object store for * saving. * * @return <code>true</code> on success, <code>false</code> otherwise. */ public boolean restore_state (InputObjectState os, int ot) { if (ot == ObjectType.ANDPERSISTENT) { try { unpackHeader(os, new Header()); } catch (IOException e) { return false; } } return true; }
/** * These methods must be provided by a derived class. They are responsible * for packing and unpacking an object's state to/from a state buffer. * StateManager calls them at appropriate times during the lifetime of the * object, and may then pass the buffer to a persistent object store for * saving. * * @return <code>true</code> on success, <code>false</code> otherwise. */ public synchronized boolean restore_state (InputObjectState os, int ot) { if (ot == ObjectType.ANDPERSISTENT) { try { unpackHeader(os, new Header()); } catch (IOException e) { return false; } } return true; }
/** * These methods must be provided by a derived class. They are responsible * for packing and unpacking an object's state to/from a state buffer. * StateManager calls them at appropriate times during the lifetime of the * object, and may then pass the buffer to a persistent object store for * saving. * * Data items must be unpacked in the same order that they were packed. * * @return <code>true</code> on success, <code>false</code> otherwise. */ public synchronized boolean restore_state (InputObjectState os, int ot) { if (ot == ObjectType.ANDPERSISTENT) { try { unpackHeader(os, new Header()); } catch (IOException e) { return false; } } return true; }
/** * These methods must be provided by a derived class. They are responsible * for packing and unpacking an object's state to/from a state buffer. * StateManager calls them at appropriate times during the lifetime of the * object, and may then pass the buffer to a persistent object store for * saving. * * Data items must be unpacked in the same order that they were packed. * * @return <code>true</code> on success, <code>false</code> otherwise. */ public synchronized boolean restore_state (InputObjectState os, int ot) { if (ot == ObjectType.ANDPERSISTENT) { try { unpackHeader(os, new Header()); } catch (IOException e) { return false; } } return true; }
/** * These methods must be provided by a derived class. They are responsible * for packing and unpacking an object's state to/from a state buffer. * StateManager calls them at appropriate times during the lifetime of the * object, and may then pass the buffer to a persistent object store for * saving. * * Data items must be unpacked in the same order that they were packed. * * @return <code>true</code> on success, <code>false</code> otherwise. */ public synchronized boolean restore_state (InputObjectState os, int ot) { if (ot == ObjectType.ANDPERSISTENT) { try { unpackHeader(os, new Header()); } catch (IOException e) { return false; } } return true; }
/** * These methods must be provided by a derived class. They are responsible * for packing and unpacking an object's state to/from a state buffer. * StateManager calls them at appropriate times during the lifetime of the * object, and may then pass the buffer to a persistent object store for * saving. * * Data items must be unpacked in the same order that they were packed. * * @return <code>true</code> on success, <code>false</code> otherwise. */ public synchronized boolean restore_state (InputObjectState os, int ot) { if (ot == ObjectType.ANDPERSISTENT) { try { unpackHeader(os, new Header()); } catch (IOException e) { return false; } } return true; }
/** * These methods must be provided by a derived class. They are responsible * for packing and unpacking an object's state to/from a state buffer. * StateManager calls them at appropriate times during the lifetime of the * object, and may then pass the buffer to a persistent object store for * saving. * * Data items must be unpacked in the same order that they were packed. * * @return <code>true</code> on success, <code>false</code> otherwise. */ public synchronized boolean restore_state (InputObjectState os, int ot) { if (ot == ObjectType.ANDPERSISTENT) { try { unpackHeader(os, new Header()); } catch (IOException e) { return false; } } return true; }
/** * These methods must be provided by a derived class. They are responsible * for packing and unpacking an object's state to/from a state buffer. * StateManager calls them at appropriate times during the lifetime of the * object, and may then pass the buffer to a persistent object store for * saving. * * Data items must be unpacked in the same order that they were packed. * * @return <code>true</code> on success, <code>false</code> otherwise. */ public synchronized boolean restore_state (InputObjectState os, int ot) { if (ot == ObjectType.ANDPERSISTENT) { try { unpackHeader(os, new Header()); } catch (IOException e) { return false; } } return true; }