示例#1
0
        protected BreakingEngine SelectEngine(char c)
        {
            if (_breakingEngine.CanHandle(c))
            {
                return(_breakingEngine);
            }
            else
            {
                //find other engine
                for (int i = _otherEngines.Count - 1; i >= 0; --i)
                {
                    //not the current engine
                    //and can handle the character
                    BreakingEngine engine = _otherEngines[i];
                    if (engine != _breakingEngine && engine.CanHandle(c))
                    {
                        return(engine);
                    }
                }

                //default
#if DEBUG
                if (!_engBreakingEngine.CanHandle(c))
                {
                    //even default can't handle the char
                }
#endif
                return(_engBreakingEngine);
            }
        }
示例#2
0
 public CustomBreaker()
 {
     ThrowIfCharOutOfRange = false;
     //
     _visitor        = new WordVisitor();
     _breakingEngine = _engBreakingEngine; //default eng-breaking engine
 }
示例#3
0
        public void BreakWords(char[] charBuff, int startAt, int len)
        {
            //conver to char buffer
            int j = charBuff.Length;

            if (j < 1)
            {
                _endAt = 0;
                return;
            }
            _endAt = startAt + len;
            _visitor.LoadText(charBuff, startAt, len);
            //----------------------------------------
            BreakingEngine currentEngine = _breakingEngine = SelectEngine(charBuff[startAt]);
            //----------------------------------------
            //select breaking engine
            int endAt = startAt + len;

            for (; ;)
            {
                //----------------------------------------
                currentEngine.BreakWord(_visitor, charBuff, startAt, endAt - startAt); //please note that len is decreasing
                switch (_visitor.State)
                {
                default: throw new NotSupportedException();

                case VisitorState.End:
                    //ok
                    return;

                case VisitorState.OutOfRangeChar:
                {
                    //find proper breaking engine for current char

                    BreakingEngine anotherEngine = SelectEngine(_visitor.Char);
                    if (anotherEngine == currentEngine)
                    {
                        if (ThrowIfCharOutOfRange)
                        {
                            throw new NotSupportedException($"A proper breaking engine for character '{_visitor.Char}' was not found.");
                        }
                        startAt = _visitor.CurrentIndex + 1;
                        _visitor.SetCurrentIndex(startAt);
                        _visitor.AddWordBreakAtCurrentIndex(WordKind.Unknown);
                    }
                    else
                    {
                        currentEngine = anotherEngine;
                        startAt       = _visitor.CurrentIndex;
                    }
                }
                break;
                }
            }
        }
示例#4
0
        public void BreakWords(char[] charBuff, int startAt, int len)
        {
            //conver to char buffer

            int j = charBuff.Length;

            if (j < 1)
            {
                visitor.ResetText();
                _endAt = 0;
                return;
            }
            _endAt = startAt + len;
            visitor.LoadText(charBuff, startAt);
            //----------------------------------------
            BreakingEngine currentEngine = breakingEngine = SelectEngine(charBuff[startAt]);
            //----------------------------------------
            //select breaking engine
            int endAt = startAt + len;

            for (; ;)
            {
                //----------------------------------------
                currentEngine.BreakWord(visitor, charBuff, startAt, endAt - startAt); //please note that len is decreasing
                switch (visitor.State)
                {
                default: throw new NotSupportedException();

                case VisitorState.End:
                    //ok
                    return;

                case VisitorState.OutOfRangeChar:
                {
                    //find proper breaking engine for current char

                    BreakingEngine anotherEngine = SelectEngine(visitor.Char);
                    if (anotherEngine == currentEngine)
                    {
                        throw new NotSupportedException();
                    }
                    else
                    {
                        currentEngine = anotherEngine;
                        startAt       = visitor.CurrentIndex;
                    }
                }
                break;
                }
            }
        }
示例#5
0
        public void BreakWords(char[] charBuff, int startAt)
        {
            //conver to char buffer
            int j = charBuff.Length;

            textLength = j;
            visitor.LoadText(charBuff, 0);
            //----------------------------------------
            BreakingEngine currentEngine = breakingEngine = SelectEngine(charBuff[startAt]);

            //----------------------------------------
            //select breaking engine
            for (;;)
            {
                //----------------------------------------
                currentEngine.BreakWord(visitor, charBuff, startAt, charBuff.Length - startAt);
                switch (visitor.State)
                {
                default: throw new NotSupportedException();

                case VisitorState.End:
                    //ok
                    return;

                case VisitorState.OutOfRangeChar:
                {
                    //find proper breaking engine for current char

                    BreakingEngine anotherEngine = SelectEngine(visitor.Char);
                    if (anotherEngine == currentEngine)
                    {
                        throw new NotSupportedException();
                    }
                    else
                    {
                        currentEngine = anotherEngine;
                        startAt       = visitor.CurrentIndex;
                    }
                }
                break;
                }
            }
        }
示例#6
0
        BreakingEngine SelectEngine(char c)
        {
            if (breakingEngine.CanHandle(c))
            {
                return(breakingEngine);
            }
            else
            {
                //find other engine
                for (int i = otherEngines.Count - 1; i >= 0; --i)
                {
                    //not the current engine
                    //and can handle the character
                    BreakingEngine engine = otherEngines[i];
                    if (engine != breakingEngine && engine.CanHandle(c))
                    {
                        return(engine);
                    }
                }

                return(engBreakingEngine);
            }
        }
示例#7
0
 public CustomBreaker()
 {
     ThrowIfCharOutOfRange = false;
     _breakingEngine       = _engBreakingEngine; //default eng-breaking engine
 }
示例#8
0
 public void AddBreakingEngine(BreakingEngine engine)
 {
     //TODO: make this accept more than 1 engine
     otherEngines.Add(engine);
     breakingEngine = engine;
 }
示例#9
0
 public CustomBreaker()
 {
     visitor        = new WordVisitor(this);
     breakingEngine = engBreakingEngine;
 }