xml-dev - Re: XObjects

[Graham Moore <graham.moore@dpsl.co.uk>]

I think Tyler is right when he says that having access to the parser events 
is useful. While the SaxInput should remain in the domBuilder interface 
could one extension be something more raw.

         build(URL xml); for example. The domBuilder can create its own 
parser set itself to be the event sink and build the DOM from the events.

Tyler wrote >

>The DOM is a general purpose tree for storing the parsed contents of an XML
>stream.  I really don't like this subclassing idea very much though as the 
DOM
>I believe is not suitable for this type of framework since you are no just
>dealing with Element nodes but you are dealing with all kinds of nodes.

Yes but at the end of the day a node is a node is a node. And isn't 
"is-a-kind-of" the time to use the inheritance pattern?

I still prefer a delegation mechanism to a simple inheritance. More dynamic, 
more powerful.

With delegation you could have a Node object, a functional object and a 
delegator object

The functional and Node objects are added to the delegator object (mix them 
in). The delegator is then the reference to the composite functionality. 
There is no dependency between the functional and Node objects.

>  I prefer a framework which says nothing about how the object tree is 
created or
> even if there is an object tree.  The application should be responsible 
for
> doing this...

The application is responsible. Its the application that gives the 
domBuilder the construction rules / element bindings / delegation structures 
that it wants applied. And the app gets back a functional dom or set of 
objects.

> So if I have a rectangle object that has 4 possible children, x, y, width, 
and
> height the code for implementing the forElementName method would be 
something
> like:

> public Element forElementName(String name, int index) {
>   if (name == "x") {
>    this.x = new X();
>    return x;
>   }
>  else if (name == "y") {
>    this.y = new Y();
>    return y;
>  }
>  else if (name == "width") {
>    this.width = new Width();
>    return width;
>  }
>  else if (name == "height") {
>    this.height = new Height();
>    return height;
>  }
>  return null;
>}

> where objects X, Y, Width, and Height implement the element interface as 
well.
> Of course it would make much more sense to treat all of these as 
attributes
> here, but I am just using this as an example.

The generic form of this is....

public gdo createFunctionalXMLObject(gdo parent, String className){
    gdo result= null;
    try {
      Class c = Class.forName(PACKAGE + ". " + className);
      Constructor cons = c.getConstructors()[0];
      result = (gdo)cons.newInstance(null);
      result.init(parent,elemName);
    } catch (Exception e){
      System.out.println("Class creation error : " + e);
    }
    return result;
}

Where PACKAGE  is the java package name.

I think this is pretty much the way the SUN ea stuff works already.

Assumptions here are that

a) the functional class subclasses from gdo (generic data object) / Node.
b) there is a default constructor that takes no arguments.

Comparing the two examples : for every application where you need 
functionality attached to XML objects

In the generic scenerio the application writer merely specifies the bindings 
and writes ONLY the new functional class, if a new one needs to be written. 
This means they dont have to write the builder or implement the DOM node 
methods.

Notice also how

in VB
set x = CreateObject(PACKAGE & "." & className)

in C++
obj = CoCreateInstance(PACKAGE + "." + className);

and in python
x = OleCreate(PACKAGE + "." + className) - I can't remember the function 
call but its something like that. Paul knows.

Would work.


In addition I think the thing to remember is that someone has structured the 
XML as it is for a reason. If there is no interest in maintiaining the 
structure but a set of functional objects are required then either :

1) The xml is a single container with a flat list of children

or

2) The domBuilder is configured to return a collection of objects that it 
builds from the XML. If there is no mapping then you get the generic data 
object.

> I think it would be a shame if this XOS API (or whatever it is named) 
favored
> some registry based interface or mapping interface cause everyone has 
already
> done these sort of things already for all kinds of applications and in the 
end
> you usually find yourself in a configuration nightmare maintaining all of
> these
> mappings.

Yes, but at some stage you need to know the functional object to build. 
Where in your example above do you find the class 'Height' is it local to 
the application package?, the domBuilder package?. There needs to be some 
mechanism for specifying the binding. I think that using the element name as 
a direct mapping into the current package will lead to problems further down 
the line.

graham.

gdm@dpsl.co.uk





xml-dev: A list for W3C XML Developers. To post, mailto:xml-dev@ic.ac.uk
Archived as: http://www.lists.ic.ac.uk/hypermail/xml-dev/
To (un)subscribe, mailto:majordomo@ic.ac.uk the following message;
(un)subscribe xml-dev
To subscribe to the digests, mailto:majordomo@ic.ac.uk the following message;
subscribe xml-dev-digest
List coordinator, Henry Rzepa (mailto:rzepa@ic.ac.uk)