source: trunk/greenstone3-extensions/gs3build/src/org/greenstone/gsdl3/gs3build/util/HTMLLoadManager.java@ 12188

package org.greenstone.gsdl3.gs3build.util;

import java.net.*;
import java.util.*;

class HTMLLoadManager implements Runnable
{   Vector          toLoad;
    Vector          loading;
    Vector          loaded;
    boolean         stopFlag;
    boolean         started;
    Thread          thread;
    static int  running;

    static
    {   running = 0;
    }

    /**
     *  Vanilla constructor of an object to load HTML documents in the background
     */
    public HTMLLoadManager()
    {   this.toLoad     = new Vector();
        this.loading    = new Vector();
        this.loaded     = new Vector();
        this.thread     = null;
        this.stopFlag   = false;
        this.started    = false;
    }

    /**
     *  Check if a given document is loading
     *
     *  @return <code>boolean</code> whether the document is loading or not
     */
    public boolean isLoading(String docURL)
    {   int i;

        for (i = 0; i < this.toLoad.size(); i ++)
        {   if (this.toLoad.elementAt(i).toString().equals(docURL))
            {   return true;
            }
        }

        for (i = 0; i < this.loading.size(); i ++)
        {   if (((HTMLDoc) this.loading.elementAt(i)).urlString().equals(docURL))
            {   return true;
            }
        }

        for (i = 0; i < this.loaded.size(); i ++)
        {   if (((HTMLDoc) this.loaded.elementAt(i)).urlString().equals(docURL))
            {   return true;
            }
        }
        return false;
    }

    /**
     *  Start this object as a thread
     */
    public synchronized void start()
    {   if (this.thread == null)
        {   this.thread = new Thread(this);
            this.thread.start();        // start the thread
            this.stopFlag   = false;    // reset the stop flag as it could have been reset
            this.started    = true;     // note that we're running
            running ++;
        }
    } 

    /**
     *  The main thread function; it calls a number of private service functions to
     *  achieve it's affect.  Once the stop flag is set, it runs until all loading
     *  documents are loaded, then stops.
     */
    public void run()
    { int i;

        while (this.stopFlag == false || this.loading.size() > 0)
        {   // slumber while there's nothing to do
            while (this.toLoad.size() == 0 && this.loading.size() == 0)
            {   try
                {
                    thread.sleep(100);
                }
                catch (InterruptedException ex)
                {
                }
            }

            // first check for finished documents
            i = 0;
            while (i < this.loading.size())
            {   HTMLDoc doc = (HTMLDoc) this.loading.elementAt(i);

                if (doc.ready())
                {   this.deschedule(i);
                }
                else
                {   i ++;
                }
            }

            // then check for a document to load
            while (this.stopFlag == false &&
                         this.toLoad.size() > 0 &&
                         this.loading.size() < 10)
            {   this.scheduleNext();
            }
        }
        this.started = false;
        running --;
    }

    /**
     *  Returns the total number of loader managers running at this time
     *
     *  @return <code>int</code> the number of managers running.
     */
    public synchronized int running()
    {   return running;
    }

    private synchronized void scheduleNext()
    {   // pop url from list to load
        URL docURL  = (URL) this.toLoad.elementAt(0);
        this.toLoad.removeElementAt(0);

        // generate new document and add it to the "loading" vector;
        // the document content is loaded in another thread
        HTMLDoc doc = new HTMLDoc(docURL, 1);
        this.loading.addElement(doc);
    }

    private synchronized void deschedule(int i)
    {   // get the document and place it in the loaded list
        HTMLDoc doc = (HTMLDoc) this.loading.elementAt(i);
        this.loaded.addElement(doc);

        // remove it from the loading list
        this.loading.removeElementAt(i);
    }

    /**
     *  Get a loaded document, not blocking if nothing is ready yet.
     *
     *  @return <code>HTMLDoc</code> the document; NB. this may be <code>null</code> as
     *                               it is not guaranteed that there is currently a loaded
     *                               document.
     */
    public synchronized HTMLDoc nextLoaded()
    {   HTMLDoc reply;

        // if nothing is loaded, return null
        if (this.loaded.size() == 0)
        {   return null;
        }

        // get the first element from the loaded vector and return it,
        // removing it from the vector in the meantime
        reply = (HTMLDoc) this.loaded.elementAt(0);
        this.loaded.removeElementAt(0);
        return reply;
    }

    /**
     *  Request the loading of a document; this does not block but schedules
     *  the document for loading.
     *
     *  @param <code>URL</code> the URL of the document to load
     */
    public synchronized void load(URL docURL)
    {   // check if it's being loaded already; if so do nothing
        if (this.isLoading(docURL.toString()) == false)
        {   this.toLoad.addElement(docURL);

            // self-start if the loading thread isn't running
            if (this.started == false)
            {   this.start();
            }
        }
    }

    /**
     *  Get the total number of documents loading/loaded through this loader
     *
     *  @param <code>int</code> the number of documents
     */
    public synchronized int loadingDocs()
    {   return this.toLoad.size() + this.loading.size() + this.loaded.size();
    }

    /**
     *  Instruct the manager to stop loading documents
     */
    public synchronized void stopLoading()
    {   this.stopFlag = true;
    }

    protected void finalize() throws Throwable
    {   this.thread     = null;
        this.loading    = null;
        this.toLoad     = null;
        this.loaded     = null;
        super.finalize();
    }
}