'NOP' filter

This section explains how to parse and render HTML page in PageMixer framework.

Overview

Class diagram

Class diagram in this section is shown below:

Class diagram (click for large figure)

Classes which you must define are colored, and other are already defined.

Object diagram

Object diagram in this section is shown below:

Object diagram (click for large figure)

Sequence diagram

Processing flow of parsing and renderring of HTML page is shown as below:

1. create your specific Filter
2. create Renderer instance
3. get(or create) Producer instance
4. create ConsumerContext instance
5. connect your Filter to Renderer
6. invoke Producer#produce with Filter and ConsumerContext

And sequence diagram after Producer#produce invocation is shown below.

Sequence diagram (click for large figure)

Class names

In this tutorial, abbreviated class names are used. Complete names are shown below.

Classes of PageMixer framework

Tutorial specific classes

Define 'NOP' filter

At first, define filter which does nothing(NOP:No OPeration) but passes token sequence to connected consumer.

public class NopFilter
    extends Filter
{
    public NopFilter(){ super(); }

    public void consume(ConsumerContext context, Token token){
        getConsumer().consume(context, token);
    }

    public void flush(ConsumerContext context){
        getConsumer().flush(context);
    }
}

Both "consume" and "flush" methods only invoke same signature method of Consumer to which it is connected.

Create Renderer

In PageMixer framework, HTML page is treated as Token sequence. But string(or byte-stream) representation must be needed to show HTML page as result of processing.

"Renderer" class renders token sequence on java.io.Writer specified at construction. For example, Renderer writing on standard-out is created by:

Renderer renderer =
new Renderer(new OutputStreamWriter(System.out));

Create Producer

Once again, In PageMixer framework, HTML page is treated as "Token" sequence. So you must get "Producer", the provider of token sequence.

There is very easy way to create Producer which provides token sequence representing specified HTML page. It is to use "PageParser" and "LoosePageState".

LoosePageState pageState = new LoosePageState();
PageParser parser = new PageParser(pageState);
Producer producer = parser.parse(filename);

Variable "filename" contains filename of HTML page.

Create ConsumerContext

"ConsumerContext" is created for dynamic values and inter-filter communication.

For stand-alone environment, there is "HashMapConsumerContext" class which implements ConsumerContext interface with java.util.HashMap, and you can create it as below:

HashMapConsumerContext context = 
new HashMapConsumerContext();

To know how to create this(or what class you should use) is important even though nothing needs this "context" in this section.

Connect and mix

Now, everything needed are ready to use. To parse and render HTML page, you should do only below steps.

1. create NopFilter
2. connect NopFilter to Renderer
3. invoke Producer#produce with NopFilter and ConsumerContext

NopFilter filter = new NopFilter(); // --- (1)
filter.connectTo(renderer); // --- (2)

producer.produce(context, filter); // --- (3)

In fact, utility class "Bootstrap", or its derived classes, assists each steps described from "Create Renderer" to "Connect and Mix"(this sub section).

You can get rendered HTML page from standard-out by as below.

1. Create instance of "Bootstrap.Default" with filename of HTML page to parse
2. invoke "execute(Filter)" with your specific Filter

Execution code is as below (see pagemixer.filter.NopFilter for detail).

try{
    Bootstrap bootstrap =
    new Bootstrap.Default(filename);

    bootstrap.execute(new NopFilter());
}
catch(Exception e){
    e.printStackTrace(System.err);
}