Uses of Package
org.htmlparser.nodeDecorators

Packages that use org.htmlparser.nodeDecorators

org.htmlparser.nodeDecorators

The nodeDecorators package contains classes that use the Decorator pattern.

Classes in org.htmlparser.nodeDecorators used by org.htmlparser.nodeDecorators

AbstractNodeDecorator
Deprecated. Use direct subclasses or dynamic proxies instead.

Use either direct subclasses of the appropriate node and set them on the PrototypicalNodeFactory, or use a dynamic proxy implementing the required node type interface. In the former case this avoids the wrapping and delegation, while the latter case handles the wrapping and delegation without this class.

Here is an example of how to use dynamic proxies to accomplish the same effect as using decorators to wrap Text nodes:

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.htmlparser.Parser;
import org.htmlparser.PrototypicalNodeFactory;
import org.htmlparser.Text;
import org.htmlparser.nodes.TextNode;
import org.htmlparser.util.ParserException;

public class TextProxy
    implements
        InvocationHandler
{
    protected Object mObject;

    public static Object newInstance (Object object)
    {
        Class cls;

        cls = object.getClass ();
        return (Proxy.newProxyInstance (
            cls.getClassLoader (),
            cls.getInterfaces (),
            new TextProxy (object)));
    }

    private TextProxy (Object object)
    {
        mObject = object;
    }

    public Object invoke (Object proxy, Method m, Object[] args)
        throws Throwable
    {
        Object result;
        String name;
        try
        {
            result = m.invoke (mObject, args);
            name = m.getName ();
            if (name.equals ("clone"))
                result = newInstance (result); // wrap the cloned object
            else if (name.equals ("doSemanticAction")) // or other methods
               System.out.println (mObject); // do the needful on the TextNode
        }
        catch (InvocationTargetException e)
        {
            throw e.getTargetException ();
        }
        catch (Exception e)
        {
            throw new RuntimeException ("unexpected invocation exception: " +
                                       e.getMessage());
        }
        finally
        {
        }

        return (result);
    }

    public static void main (String[] args)
        throws
            ParserException
    {
        // create the wrapped text node and set it as the prototype
        Text text = (Text) TextProxy.newInstance (new TextNode (null, 0, 0));
        PrototypicalNodeFactory factory = new PrototypicalNodeFactory ();
        factory.setTextPrototype (text);
        // perform the parse
        Parser parser = new Parser (args[0]);
        parser.setNodeFactory (factory);
        parser.parse (null);
    }
}