Glueable

The primitive types (boolean, byte, short, int, long, float, double and char) are supported implicitly by the GlueEncoder.encode and GlueDecoder.decode methods. The primitive wrapper classes (Boolean, Byte, Short, Integer, Long, Float, Double, and Character) as well as the String and Enum classes are also supported without needing to implement the Glueable interface.

As a convenience, any class which implements either the java.util.Collection or java.util.Map interface is also supported without the need to implement the Glueable interface by a default mechanism. If a class implements one of these common interfaces but also implements the Glueable interface, the default encoding/decoding will be ignored in favor of the custom implementation of the Glueable interface.

In order to implement the Glueable interface, a class must provide definitions for the toGlue and fromGlue methods. Typically, the bodies of these methods will call GlueEncoder.encode and GlueDecoder.decode methods respectively for each field which should be written to and read from Glue format.

The implementing class must also have an accessible no-arg constructor. When decoded from Glue, the class will be instantiated with this no-arg constructor and then initialized by calling the fromGlue method. It is the responsibility of the implementing class to properly initialize all fields through the combination of these two methods. Typically, the no-arg constructor will setup reasonable default values for fields and the fromGlue method will override these defaults with values obtained using the GlueDecoder.decode method for each field.

For example:

 package us.temerity.pipeline;

 public class Dude 
   implements Glueable 
 {
   private String myName;
   private int    myAge;

   public Dude()
   {
     myName = "Nobody";
     myAge  = 0;
   }

   public Dude(String name, int age) 
   {
     myName = name;
     myAge  = age;
   }

   public void toGlue(GlueEncoder ge) 
     throws GlueException
   {
     ge.encode("Name", myName);
     ge.encode("Age",  myAge);
   }

   public void fromGlue(GlueDecoder gd) 
     throws GlueException
   {
     myName = (String)  gd.decode("Name");
     myAge  = (Integer) gd.decode("Age");
   }
 }

The Glue format is encodes/decodes data structures with multiple references to the same object automatically. The Glue text format only stores the full details of an object once no matter how many times it is referenced. Each object is assigned a unique ID the first time it is encoded and all subsequence references to the object refer to this ID.

Arrays of any dimension can also be encoded/decoded as long as the array component type satisfies the conditions mentioned above for non-array objects.

See Also:: GlueEncoder, GlueDecoder, Collection, Map

Method Summary
`void`	`fromGlue(GlueDecoder decoder)` Restores the non-transient fields of the class from Glue.
`void`	`toGlue(GlueEncoder encoder)` Saves the non-transient fields of this object as Glue.

Method Detail

toGlue

void toGlue(GlueEncoder encoder)
            throws GlueException

Saves the non-transient fields of this object as Glue. Typically, the implementation will call GlueEncoder.encode for each non-transient field of the parent object.

Parameters:: encoder - [modified] The object used to encode this object's fields into Glue format.
Throws:: GlueException

fromGlue

void fromGlue(GlueDecoder decoder)
              throws GlueException

Restores the non-transient fields of the class from Glue. Typically, the implementation will call GlueDecoder.decode for each non-transient field of the parent object.

Parameters:: decoder - The object used to decode this object's fields from Glue format.
Throws:: GlueException

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

TEMERITY

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

us.temerity.pipeline.glue Interface Glueable

toGlue

fromGlue

us.temerity.pipeline.glue
Interface Glueable