TeeSinkTokenFilter.cs

Go to the documentation of this file.

/* 
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

using System;
using System.Collections.Generic;
using Attribute = Lucene.Net.Util.Attribute;
using AttributeSource = Lucene.Net.Util.AttributeSource;

namespace Lucene.Net.Analysis
{
    
    public sealed class TeeSinkTokenFilter:TokenFilter
    {
        public class AnonymousClassSinkFilter:SinkFilter
        {
            public override bool Accept(AttributeSource source)
            {
                return true;
            }
        }
        private readonly LinkedList<WeakReference> sinks = new LinkedList<WeakReference>();
        
        public TeeSinkTokenFilter(TokenStream input):base(input)
        {
        }
        
        public SinkTokenStream NewSinkTokenStream()
        {
            return NewSinkTokenStream(ACCEPT_ALL_FILTER);
        }
        
        public SinkTokenStream NewSinkTokenStream(SinkFilter filter)
        {
            var sink = new SinkTokenStream(this.CloneAttributes(), filter);
            sinks.AddLast(new WeakReference(sink));
            return sink;
        }
        
        public void  AddSinkTokenStream(SinkTokenStream sink)
        {
            // check that sink has correct factory
            if (!this.Factory.Equals(sink.Factory))
            {
                throw new System.ArgumentException("The supplied sink is not compatible to this tee");
            }
            // add eventually missing attribute impls to the existing sink
            foreach (var impl in this.CloneAttributes().GetAttributeImplsIterator())
            {
                sink.AddAttributeImpl(impl);
            }
            sinks.AddLast(new WeakReference(sink));
        }
        
        public void  ConsumeAllTokens()
        {
            while (IncrementToken())
            {
            }
        }
        
        public override bool IncrementToken()
        {
            if (input.IncrementToken())
            {
                // capture state lazily - maybe no SinkFilter accepts this state
                State state = null;
                foreach(WeakReference wr in sinks)
                {
                    var sink = (SinkTokenStream)wr.Target;
                    if (sink != null)
                    {
                        if (sink.Accept(this))
                        {
                            if (state == null)
                            {
                                state = this.CaptureState();
                            }
                            sink.AddState(state);
                        }
                    }
                }
                return true;
            }
            
            return false;
        }
        
        public override void  End()
        {
            base.End();
            State finalState = CaptureState();
            foreach(WeakReference wr in sinks)
            {
                var sink = (SinkTokenStream)wr.Target;
                if (sink != null)
                {
                    sink.SetFinalState(finalState);
                }
            }
        }
        
        public abstract class SinkFilter
        {
            public abstract bool Accept(AttributeSource source);
            
            public virtual void Reset()
            {
                // nothing to do; can be overridden
            }
        }
        
        public sealed class SinkTokenStream : TokenStream
        {
            private readonly LinkedList<State> cachedStates = new LinkedList<State>();
            private State finalState;
            private IEnumerator<AttributeSource.State> it = null;
            private readonly SinkFilter filter;

            internal SinkTokenStream(AttributeSource source, SinkFilter filter)
                : base(source)
            {
                this.filter = filter;
            }
            
            internal /*private*/ bool Accept(AttributeSource source)
            {
                return filter.Accept(source);
            }
            
            internal /*private*/ void  AddState(AttributeSource.State state)
            {
                if (it != null)
                {
                    throw new System.SystemException("The tee must be consumed before sinks are consumed.");
                }
                cachedStates.AddLast(state);
            }
            
            internal /*private*/ void  SetFinalState(AttributeSource.State finalState)
            {
                this.finalState = finalState;
            }
            
            public override bool IncrementToken()
            {
                // lazy init the iterator
                if (it == null)
                {
                    it = cachedStates.GetEnumerator();
                }
                
                if (!it.MoveNext())
                {
                    return false;
                }
                
                State state = it.Current;
                RestoreState(state);
                return true;
            }
            
            public override void  End()
            {
                if (finalState != null)
                {
                    RestoreState(finalState);
                }
            }
            
            public override void  Reset()
            {
                it = cachedStates.GetEnumerator();
            }

            protected override void Dispose(bool disposing)
            {
                // Do nothing.
            }
        }
        
        private static readonly SinkFilter ACCEPT_ALL_FILTER;
        static TeeSinkTokenFilter()
        {
            ACCEPT_ALL_FILTER = new AnonymousClassSinkFilter();
        }
    }
}