AfflictionNetworks/narya
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added ability to update elements in a set.

Browse Source 
git-svn-id: svn+ssh://src.earth.threerings.net/narya/trunk@266 542714f4-19e9-0310-aa3c-eee0fc999fb1
This commit is contained in:
Michael Bayne
2001-08-16 03:45:43 +00:00
parent 2179599bd6
commit 890bad996e
6 changed files with 270 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/java/com/threerings/presents/dobj/DObject.java
+12 -1
View File
@@ -1,5 +1,5 @@
//
// $Id: DObject.java,v 1.24 2001/08/16 03:31:08 mdb Exp $
// $Id: DObject.java,v 1.25 2001/08/16 03:45:43 mdb Exp $
package com.threerings.cocktail.cher.dobj;
@@ -434,6 +434,17 @@ public class DObject
_mgr.postEvent(event);
}
/**
* Calls by derived instances when a set updater method was called.
*/
protected void requestElementUpdate (String name, DSet.Element elem)
{
// generate an element updated event
DEvent event = new ElementUpdatedEvent(_oid, name, elem);
// and dispatch it to our dobjmgr
_mgr.postEvent(event);
}
/** Our object id. */
protected int _oid;
src/java/com/threerings/presents/dobj/DSet.java
+28 -1
View File
@@ -1,5 +1,5 @@
//
// $Id: DSet.java,v 1.1 2001/08/16 03:31:09 mdb Exp $
// $Id: DSet.java,v 1.2 2001/08/16 03:45:43 mdb Exp $
package com.threerings.cocktail.cher.dobj;
@@ -219,6 +219,33 @@ public class DSet
return false;
}
/**
* Updates the specified element by locating an element whose key
* matches the key of the supplied element and overwriting it. This
* should not be called directly, instead the associated
* <code>update{Set}()</code> method should be called on the
* distributed object that contains the set in question.
*
* @return true if the element was updated, false if it was not
* already in the set (in which case nothing is updated).
*/
protected boolean update (Element elem)
{
Object key = elem.getKey();
// scan the array looking for a matching element
int elength = _elements.length;
for (int i = 0; i < elength; i++) {
Element el = _elements[i];
if (el != null && el.getKey().equals(key)) {
_elements[i] = elem;
return true;
}
}
return false;
}
protected Class _elementType;
protected Element[] _elements;
}
src/java/com/threerings/presents/dobj/EntryAddedEvent.java
+7 -76
View File
@@ -1,11 +1,14 @@
//
// $Id: EntryAddedEvent.java,v 1.2 2001/08/16 03:33:11 mdb Exp $
// $Id: EntryAddedEvent.java,v 1.3 2001/08/16 03:45:43 mdb Exp $
package com.threerings.cocktail.cher.dobj;
import java.io.*;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import com.threerings.cocktail.cher.Log;
import com.threerings.cocktail.cher.dobj.io.ElementUtil;
/**
* An element added event is dispatched when an element is added to a
@@ -74,7 +77,7 @@ public class ElementAddedEvent extends TypedEvent
// element (if need be)
if (_elem == null) {
try {
_elem = unflatten(set, _bytes);
_elem = ElementUtil.unflatten(set, _bytes);
} catch (Exception e) {
Log.warning("Error unflattening element " + this + ".");
Log.logStackTrace(e);
@@ -96,7 +99,7 @@ public class ElementAddedEvent extends TypedEvent
{
super.writeTo(out);
out.writeUTF(_name);
flatten(out, _elem);
ElementUtil.flatten(out, _elem);
}
public void readFrom (DataInputStream in)
@@ -124,76 +127,4 @@ public class ElementAddedEvent extends TypedEvent
protected String _name;
protected byte[] _bytes;
protected DSet.Element _elem;
/**
* Because we don't know the type of the element at the time that the
* event is read from the network (we only know it once the event is
* being applied to the object and we can ask the target
* <code>DSet</code> instance what type it manages), we flatten the
* element before writing it to the wire so that we can prepend it by
* a byte count. The receiver will read in the raw bytes and decode
* them only later when it has access to the <code>DSet</code>
* instance that knows what element type to use. This method should
* really only be called by the conmgr thread, but we synchronize just
* in case someone decides to write an event out in some other
* peculiar context. Uncontested syncs are pretty fast.
*/
protected static synchronized void flatten (
DataOutputStream out, DSet.Element elem)
throws IOException
{
elem.writeTo(_dout);
_dout.flush();
out.writeInt(_bout.size());
_bout.writeTo(out);
}
/**
* Unflattens an element given the serialized element data. We know
* this will always be called on the dobjmgr thread, so we need not
* synchronize.
*/
protected static DSet.Element unflatten (DSet set, byte[] data)
throws IOException
{
_bin.setBytes(data);
DSet.Element elem = set.newElement();
elem.readFrom(_din);
return elem;
}
/**
* We extend byte array input stream to avoid having to create a new
* input stream every time we unserialize an element. Our extensions
* allow us to repurpose this input stream to read from a new byte
* array each time we unserialize.
*/
protected static class ReByteArrayInputStream extends ByteArrayInputStream
{
public ReByteArrayInputStream ()
{
super(new byte[0]);
}
public void setBytes (byte[] bytes)
{
buf = bytes;
pos = 0;
count = buf.length;
mark = 0;
}
}
/** Used when serializing elements. */
protected static ByteArrayOutputStream _bout = new ByteArrayOutputStream();
/** Used when serializing elements. */
protected static DataOutputStream _dout = new DataOutputStream(_bout);
/** Used when unserializing elements. */
protected static ReByteArrayInputStream _bin =
new ReByteArrayInputStream();
/** Used when unserializing elements. */
protected static DataInputStream _din = new DataInputStream(_bin);
}
src/java/com/threerings/presents/dobj/EntryRemovedEvent.java
+2 -2
View File
@@ -1,11 +1,11 @@
//
// $Id: EntryRemovedEvent.java,v 1.2 2001/08/16 03:33:11 mdb Exp $
// $Id: EntryRemovedEvent.java,v 1.3 2001/08/16 03:45:43 mdb Exp $
package com.threerings.cocktail.cher.dobj;
import java.io.IOException;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import com.threerings.cocktail.cher.dobj.io.ValueMarshaller;
src/java/com/threerings/presents/dobj/EntryUpdatedEvent.java
+136
View File
@@ -0,0 +1,136 @@
//
// $Id: EntryUpdatedEvent.java,v 1.1 2001/08/16 03:45:43 mdb Exp $
package com.threerings.cocktail.cher.dobj;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import com.threerings.cocktail.cher.Log;
import com.threerings.cocktail.cher.dobj.io.ElementUtil;
/**
* An element updated event is dispatched when an element of a
* <code>DSet</code> is updated. It can also be constructed to request the
* update of an element and posted to the dobjmgr.
*
* @see DObjectManager#postEvent
*/
public class ElementUpdatedEvent extends TypedEvent
{
/** The typed object code for this event. */
public static final short TYPE = TYPE_BASE + 10;
/**
* Constructs a new element updated event on the specified target
* object for the specified set name and with the supplied updated
* element.
*
* @param targetOid the object id of the object to whose set we will
* add an element.
* @param name the name of the attribute in which to update the
* specified element.
* @param elem the element to update.
*/
public ElementUpdatedEvent (int targetOid, String name, DSet.Element elem)
{
super(targetOid);
_name = name;
_elem = elem;
}
/**
* Constructs a blank instance of this event in preparation for
* unserialization from the network.
*/
public ElementUpdatedEvent ()
{
}
/**
* Returns the name of the set attribute for which an element has been
* updated.
*/
public String getName ()
{
return _name;
}
/**
* Returns the element that has been updated.
*/
public DSet.Element getElement ()
{
return _elem;
}
/**
* Applies this event to the object.
*/
public boolean applyToObject (DObject target)
throws ObjectAccessException
{
DSet set = (DSet)target.getAttribute(_name);
// now that we have access to our target set, we can unflatten our
// element (if need be)
if (_elem == null) {
try {
_elem = ElementUtil.unflatten(set, _bytes);
} catch (Exception e) {
Log.warning("Error unflattening element " + this + ".");
Log.logStackTrace(e);
return false;
}
}
// update the element
if (!set.update(_elem)) {
// complain if we didn't update anything
Log.warning("No matching element to update " + this + ".");
return false;
}
return true;
}
public short getType ()
{
return TYPE;
}
public void writeTo (DataOutputStream out)
throws IOException
{
super.writeTo(out);
out.writeUTF(_name);
ElementUtil.flatten(out, _elem);
}
public void readFrom (DataInputStream in)
throws IOException
{
super.readFrom(in);
_name = in.readUTF();
// we read in the raw element data now and decode it later when we
// have access to the object and the DSet instance that knows what
// type of element we need to decode
int bcount = in.readInt();
_bytes = new byte[bcount];
in.readFully(_bytes, 0, bcount);
}
protected void toString (StringBuffer buf)
{
buf.append("ELUPD:");
super.toString(buf);
buf.append(", name=").append(_name);
buf.append(", elem=").append(_elem);
}
protected String _name;
protected byte[] _bytes;
protected DSet.Element _elem;
}
src/java/com/threerings/presents/dobj/io/EntryUtil.java
+85
View File
@@ -0,0 +1,85 @@
//
// $Id: EntryUtil.java,v 1.1 2001/08/16 03:45:43 mdb Exp $
package com.threerings.cocktail.cher.dobj.io;
import java.io.*;
import com.threerings.cocktail.cher.dobj.DSet;
/**
* Routines to simplify the process of moving set elements over the wire.
* Because we don't know the type of the element when the event is
* unserialized (we only know later when the event is applied to the
* object and the event has access to the target set object), then we need
* to do some jockeying.
*/
public class ElementUtil
{
/**
* Flattens the supplied element into a byte array, counts the number
* of bytes in the array and writes the count followed by the bytes to
* the supplied data output stream. This method should really only be
* called by the conmgr thread, but we synchronize just in case
* someone decides to write an event out in some other peculiar
* context; uncontested syncs are pretty fast.
*/
public static synchronized void flatten (
DataOutputStream out, DSet.Element elem)
throws IOException
{
elem.writeTo(_dout);
_dout.flush();
out.writeInt(_bout.size());
_bout.writeTo(out);
}
/**
* Unflattens an element given the serialized element data. We know
* this will always be called on the dobjmgr thread, so we need not
* synchronize.
*/
public static DSet.Element unflatten (DSet set, byte[] data)
throws IOException
{
_bin.setBytes(data);
DSet.Element elem = set.newElement();
elem.readFrom(_din);
return elem;
}
/**
* We extend byte array input stream to avoid having to create a new
* input stream every time we unserialize an element. Our extensions
* allow us to repurpose this input stream to read from a new byte
* array each time we unserialize.
*/
protected static class ReByteArrayInputStream extends ByteArrayInputStream
{
public ReByteArrayInputStream ()
{
super(new byte[0]);
}
public void setBytes (byte[] bytes)
{
buf = bytes;
pos = 0;
count = buf.length;
mark = 0;
}
}
/** Used when serializing elements. */
protected static ByteArrayOutputStream _bout = new ByteArrayOutputStream();
/** Used when serializing elements. */
protected static DataOutputStream _dout = new DataOutputStream(_bout);
/** Used when unserializing elements. */
protected static ReByteArrayInputStream _bin =
new ReByteArrayInputStream();
/** Used when unserializing elements. */
protected static DataInputStream _din = new DataInputStream(_bin);
}