Dont index style nodes.

[beagle.git] / beagled / QueryResult.cs

//
// QueryResult.cs
//
// Copyright (C) 2004 Novell, Inc.
//

//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//


using System;
using System.Collections;
using System.Diagnostics;
using System.Threading;
using Beagle.Util;

namespace Beagle.Daemon {

        public class QueryResult : IQueryResult, IDisposable {

                public delegate void StartedHandler (QueryResult source);
                public event StartedHandler StartedEvent;

                public delegate void HitsAddedHandler (QueryResult source, ICollection someHits);
                public event HitsAddedHandler HitsAddedEvent;

                public delegate void HitsSubtractedHandler (QueryResult source, ICollection someUris);
                public event HitsSubtractedHandler HitsSubtractedEvent;

                public delegate void FinishedHandler (QueryResult source);
                public event FinishedHandler FinishedEvent;

                //////////////////////////////////

                int workers = 0;
                bool cancelled = false;
                Hashtable uri_hash = UriFu.NewHashtable ();
                DateTime started_time;
                DateTime finished_time;
                Hashtable per_worker_started_time = new Hashtable ();
                bool is_index_listener = false;


                public QueryResult ()
                {

                }

                //////////////////////////////////

                public void Dispose () 
                {
                        lock (this) {
                                if (cancelled)
                                        return;
                                cancelled = true;
                        }       
                }

                //////////////////////////////////

                public bool Active {
                        get { return workers > 0 && ! cancelled; }
                }

                public bool Cancelled {
                        get { return cancelled; }
                }

                public bool IsIndexListener {
                        get { return is_index_listener; }
                        set { is_index_listener = value; }
                }

                public void Cancel ()
                {
                        lock (this) {
                                if (cancelled)
                                        return;
                                cancelled = true;
                        }
                }

                // Note: some_hits is allowed to contain null.
                // They are silently ignored.
                public void Add (ICollection some_hits)
                {
                        lock (this) {
                                if (cancelled)
                                        return;

                                Debug.Assert (workers > 0, "Adding Hits to idle QueryResult");

                                if (some_hits.Count == 0)
                                        return;

                                if (IsIndexListener) {
                                        if (HitsAddedEvent != null)
                                                HitsAddedEvent (this, some_hits);
                                        return;
                                }

                                // Be careful not to report the same hit twice.
                                ArrayList hits_to_report;
                                hits_to_report = new ArrayList ();
                                foreach (Hit hit in some_hits) {
                                        if (hit != null && ! uri_hash.Contains (hit.Uri)) {
                                                uri_hash [hit.Uri] = hit;
                                                hits_to_report.Add (hit);
                                        }
                                }
                                
                                if (HitsAddedEvent != null && hits_to_report.Count > 0)
                                        HitsAddedEvent (this, hits_to_report);
                        }
                }

                // Note: some_uris is allowed to contain null.
                // They are silently ignored.
                public void Subtract (ICollection some_uris)
                {
                        lock (this) {
                                if (cancelled)
                                        return;

                                Debug.Assert (workers > 0, "Subtracting Hits from idle QueryResult");

                                if (some_uris.Count == 0)
                                        return;
                                
                                if (IsIndexListener) {
                                        if (HitsSubtractedEvent != null)
                                                HitsSubtractedEvent (this, some_uris);
                                        return;
                                }

                                ArrayList filtered_uris = new ArrayList ();

                                // We only get to subtract a URI if it was previously added.
                                foreach (Uri uri in some_uris) {
                                        if (uri != null && uri_hash.Contains (uri)) {
                                                filtered_uris.Add (uri);
                                                uri_hash.Remove (uri);
                                        }
                                }

                                if (HitsSubtractedEvent != null && filtered_uris.Count > 0)
                                        HitsSubtractedEvent (this, filtered_uris);
                        }
                }

                //////////////////////////////////

                // Given the Uri of a Hit contained in the QueryResult, return that Hit.
                public Hit GetHitFromUri (Uri uri)
                {
                        return uri_hash [uri] as Hit;
                }

                public ICollection HitUris {
                        get { return uri_hash.Keys; }
                }

                //////////////////////////////////////////////////////////////////////////////////////

                class QueryWorkerClosure {
                        IQueryWorker worker;
                        QueryResult result;

                        public QueryWorkerClosure (IQueryWorker _worker, QueryResult _result)
                        {
                                worker = _worker;
                                result = _result;
                        }

                        public void Start ()
                        {
                                try {
                                        worker.DoWork ();
                                } catch (Exception e) {
                                        Logger.Log.Error ("QueryWorker '{0}' threw an exception", worker);
                                        Logger.Log.Error (e);
                                }
                                try {
                                        result.WorkerFinished (worker);
                                } catch (Exception e) {
                                        Logger.Log.Error ("QueryResult threw an exception while calling WorkerFinished for '{0}'",
                                                          worker);
                                }
                        }
                }

                public void AttachWorker (IQueryWorker worker)
                {
                        lock (this) {
                                if (cancelled)
                                        return;

                                QueryWorkerClosure qwc;
                                qwc = new QueryWorkerClosure (worker, this);

                                // QueryDriver has an enclosing WorkerStart,
                                // so if we call WorkerStart in this thread, 
                                // all the workers will have a chance 
                                // to start before Finished is called
                                
                                if (!WorkerStartNoLock (worker)) 
                                        return;

                                ExceptionHandlingThread.Start (new ThreadStart (qwc.Start));
                        }
                }

                private bool WorkerStartNoLock (object o)
                {
                        if (!Shutdown.WorkerStart (o))
                                return false;

                        DateTime now = DateTime.Now;
                        per_worker_started_time [o] = now;
                        ++workers;
                        if (workers == 1) {
                                started_time = now;
                                if (StartedEvent != null) 
                                        StartedEvent (this);
                        }


                        return true;
                        
                }

                internal bool WorkerStart (object o)
                {
                        lock (this) {
                                return WorkerStartNoLock (o);
                        }
                }

                internal void WorkerFinished (object o)
                {
                        lock (this) {
                                Debug.Assert (workers > 0, "Too many calls to WorkerFinished");
                                --workers;


                                DateTime now = DateTime.Now;

                                //DateTime then = (DateTime) per_worker_started_time [o];
                                //Logger.Log.Debug ("{0} finished in {1:0.00}s", o, (now - then).TotalSeconds);

                                if (workers == 0) {
                                        finished_time = now;
                                        //Logger.Log.Debug ("Last worker finished {0:0.00}s after start",
                                        //(finished_time - started_time).TotalSeconds);
                                        if (FinishedEvent != null)
                                                FinishedEvent (this);
                                        Monitor.Pulse (this);
                                }
                        }
                        Shutdown.WorkerFinished (o);
                }

                public void Wait ()
                {
                        lock (this) {
                                while (true) {
                                        if (cancelled || workers == 0)
                                                return;
                                        Monitor.Wait (this);
                                }
                        }
                }
        }
}