Lecture 20 – April 2, 2002 Bond Objects

Bond objects extend Java objects Every Bond object is assigned a unique identifier for the lifetime of the object. An entire collection of Bond objects can be identified by an alias. Communication support: All Bond objects are capable of receiving messages. Active objects can also send messages.

Bond objects extend Java objects Bond objects are registered at the creation time with a local directory. They can be found using either the unique identifier or the alias. Lightweight Bond objects (messages and shadows) are registered on demand. All Bond objects are serializable and clonable, while only some Java objects are.

Bond objects extend Java objects Bond objects may have dynamic properties created at run-time, in addition to the regular fields of a Java object. The Bond system extends the Java object model with multiple inheritance using a preprocessor of Java files. All Bond objects can be visually edited.

Bond Identifiers bondID= ``bondID'' + bondIPaddress + commEnginePort + localMillisecondSinceStartOfResident + timeAndDate

Bond object registration public class bondObject implements Serializable, Cloneable { public bondObject() { maybeInformDirectory(); if (bondID != null) { setName(bondID); } } protected void maybeInformDirectory() { try { bondID = dir.getBondID(); dir.register(this); } catch (NullPointerException e) }

Bond Resident Initialization public static void initbond() { bondConfiguration.initSysProperties(); loader = new bondLoader(); dir = new bondDirectory(); com = new bondCommunicator(); conf = new bondConfiguration(); bondMessage.initMessage(); return; }

Bond shadows

Bond shadows /** Create shadow from bondID and address of object*/ public bondShadow(String remote_bondID, String rem_address){ super(false); this.remote_bondID= remote_bondID; remote_address = new bondIPAddress(rem_address); }

Make a local copy of a remote object public bondObject realize() { bondID = dir.getBondID(); dir.register(this); bondObject bo = null; if (local != null) { return local; } else { bondMessage m =new bondMessage( "(tell :content realize)", "PropertyAccess"); m.setNeedsReply(); say(m, this); m.waitReply(30000); return m.bo; } }

Reflection and Introspection in Java The compilers and linkers for programming languages such as C or C++ usually discard the names of the variables, keeping only their addresses in the compiled code. Java, keeps this information in the compiled class files and allows access to it through a mechanism called reflection. Introspection, the ability to change dynamically the static properties of an object. E.g. Java beans.

Dynamic Properties of Bond Objects Dynamic properties are important for software agents, their functionality makes it difficult to anticipate all the fields of an agent at the instance the agent is created. For efficiency reasons regular Java fields should be used whenever possible, and we should resort to dynamic fields only when the name and/or type of the field is not known at compile time. Dynamic properties have a longer access time than regular Java fields. For remote object}s this difference is masked by the network latency. Compile-time type checking cannot be done for dynamic properties; thus, the programmer looses important type-safety information.

Dynamic Properties of Bond Objects All dynamic properties are considered to be of type Object and any value can be set for them. To delete a dynamic property, the value is set to null. Bond objects implement a common interface with two methods: get and set to access static fields and dynamic properties.

get get(String name); -- returns the value of the field or dynamic property called ``name''. Numerical values, which are not objects in Java, are first converted to their object counterpart, e.g., an int is converted to an Integer object. The get function returns null when there is no object or field with the given name.

set set(String name, Object value);-- sets the value of the field or dynamic property called name to the value specified by value. If there is no field or dynamic property with the given name, a new dynamic property is created. If there is a field with the given name but its type conflicts with the type of the object value, a casting exception is thrown.

Example Assume we have a Bond object foo with boo as a field: foo.set(``boo.name'', ``hector'')}. String val =foo.get(``boo.name'')}