Package de.lmu.ifi.pms.spex.engine.messages

This package contains Spex message implementations.

See:
Description

Interface Summary

Message

Spex messages represent nodes in an XML stream.

Class Summary

AnnotationMessage	Sometimes annotations are not directly related to another message.
AttributeMessage	This class represents attribute messages.
ClosingTagMessage	This class represents closing tag messages.
DocumentEndMessage	This class represents document end messages.
DocumentStartMessage	This class represents document start messages.
Message.Link	To be used by the creator of messages (that is the Spex XMLStreamProcessor implementation in class SpexProcessor).
OpeningTagMessage	This class represents opening tag messages.
TextMessage	This class represents text messages.

Package de.lmu.ifi.pms.spex.engine.messages Description

This package contains Spex message implementations. Spex messages represent nodes in an XML stream. The Spex processor implementation of the XMLStreamProcessor interface will generate a message for every node encountered in the XML stream it's XMLStreamParser notifies him about. The Spex processor will generate an appropriate message for each different node type in the stream. For example encountering opening tags in the XML stream will lead to OpeningTagMessages to get created.

After getting created a message will be forwarded to the InputTransducer of a Spex transducer network. It will then be forwarded from one transducer to another until it reaches the OutputTransducer. At that time the message will eventually be kept in a buffer for result printing or all references to it will be cut off, making it capable for garbage collection.

Some message types can get annotated by the transducers with Spex annotations with the Message.setAnnotation(Annotation) method. Others will throw an exception (subclasses should document this). You can check, whether an message can be annotated or not, with the Message.canBeAnnotated() method.

Also some messages of this package are extending the ResultCandidate class, which makes them capable of being possible (beginnings of) spex results and getting registered to the ResultBuffer. This result candidates can be annotated by head transducers with HeadAnnotations.

Messages get linked together at creation time. Every message has a reference to it's direct successor. This successor can be returned by the Message.getNext() method. But remember, that the stream parser may not yet have notified the stream processor about the succeeding XML node. This will result in the Message.getNext() method returning null, until the succeeding message gets created. You can cut off this references with the Message.cutLink() method.

Copyright Notice

Code Authors: Fatih Coskun
Design Authors: Fatih Coskun, Dan Olteanu


This SPEX version is based on previous versions developped by Dan Olteanu
and on research articles that can be found at
http://www.pms.informatik.uni-muenchen.de/publikationen/


The material distributed here have been provided by the contributing authors
as a means to ensure timely dissemination of technical and scholarly work on
a noncommercial basis.


Copyright and all rights therein are maintained by the authors.


It is understood that all persons copying material distributed here will
adhere to the terms and constraints implied by the applicable copyrights.
The code distributed here may not be redistributed -- in particular may not
be electronically reposted -- without the explicit permission of the
copyright holders.


The material made available here is exclusively for private use. No part of
it may be distributed in classes or in publications, reproduced, stored in a
retrieval system, or published, in any form or by means electronic,
mechanical, photocopying, or otherwise, without prior written permission of
the authors and of the copyright holders.