source: code/trunk/vendor/golang.org/x/text/runes/cond.go@ 145

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package runes

import (
        "unicode/utf8"

        "golang.org/x/text/transform"
)

// Note: below we pass invalid UTF-8 to the tIn and tNotIn transformers as is.
// This is done for various reasons:
// - To retain the semantics of the Nop transformer: if input is passed to a Nop
//   one would expect it to be unchanged.
// - It would be very expensive to pass a converted RuneError to a transformer:
//   a transformer might need more source bytes after RuneError, meaning that
//   the only way to pass it safely is to create a new buffer and manage the
//   intermingling of RuneErrors and normal input.
// - Many transformers leave ill-formed UTF-8 as is, so this is not
//   inconsistent. Generally ill-formed UTF-8 is only replaced if it is a
//   logical consequence of the operation (as for Map) or if it otherwise would
//   pose security concerns (as for Remove).
// - An alternative would be to return an error on ill-formed UTF-8, but this
//   would be inconsistent with other operations.

// If returns a transformer that applies tIn to consecutive runes for which
// s.Contains(r) and tNotIn to consecutive runes for which !s.Contains(r). Reset
// is called on tIn and tNotIn at the start of each run. A Nop transformer will
// substitute a nil value passed to tIn or tNotIn. Invalid UTF-8 is translated
// to RuneError to determine which transformer to apply, but is passed as is to
// the respective transformer.
func If(s Set, tIn, tNotIn transform.Transformer) Transformer {
        if tIn == nil && tNotIn == nil {
                return Transformer{transform.Nop}
        }
        if tIn == nil {
                tIn = transform.Nop
        }
        if tNotIn == nil {
                tNotIn = transform.Nop
        }
        sIn, ok := tIn.(transform.SpanningTransformer)
        if !ok {
                sIn = dummySpan{tIn}
        }
        sNotIn, ok := tNotIn.(transform.SpanningTransformer)
        if !ok {
                sNotIn = dummySpan{tNotIn}
        }

        a := &cond{
                tIn:    sIn,
                tNotIn: sNotIn,
                f:      s.Contains,
        }
        a.Reset()
        return Transformer{a}
}

type dummySpan struct{ transform.Transformer }

func (d dummySpan) Span(src []byte, atEOF bool) (n int, err error) {
        return 0, transform.ErrEndOfSpan
}

type cond struct {
        tIn, tNotIn transform.SpanningTransformer
        f           func(rune) bool
        check       func(rune) bool               // current check to perform
        t           transform.SpanningTransformer // current transformer to use
}

// Reset implements transform.Transformer.
func (t *cond) Reset() {
        t.check = t.is
        t.t = t.tIn
        t.t.Reset() // notIn will be reset on first usage.
}

func (t *cond) is(r rune) bool {
        if t.f(r) {
                return true
        }
        t.check = t.isNot
        t.t = t.tNotIn
        t.tNotIn.Reset()
        return false
}

func (t *cond) isNot(r rune) bool {
        if !t.f(r) {
                return true
        }
        t.check = t.is
        t.t = t.tIn
        t.tIn.Reset()
        return false
}

// This implementation of Span doesn't help all too much, but it needs to be
// there to satisfy this package's Transformer interface.
// TODO: there are certainly room for improvements, though. For example, if
// t.t == transform.Nop (which will a common occurrence) it will save a bundle
// to special-case that loop.
func (t *cond) Span(src []byte, atEOF bool) (n int, err error) {
        p := 0
        for n < len(src) && err == nil {
                // Don't process too much at a time as the Spanner that will be
                // called on this block may terminate early.
                const maxChunk = 4096
                max := len(src)
                if v := n + maxChunk; v < max {
                        max = v
                }
                atEnd := false
                size := 0
                current := t.t
                for ; p < max; p += size {
                        r := rune(src[p])
                        if r < utf8.RuneSelf {
                                size = 1
                        } else if r, size = utf8.DecodeRune(src[p:]); size == 1 {
                                if !atEOF && !utf8.FullRune(src[p:]) {
                                        err = transform.ErrShortSrc
                                        break
                                }
                        }
                        if !t.check(r) {
                                // The next rune will be the start of a new run.
                                atEnd = true
                                break
                        }
                }
                n2, err2 := current.Span(src[n:p], atEnd || (atEOF && p == len(src)))
                n += n2
                if err2 != nil {
                        return n, err2
                }
                // At this point either err != nil or t.check will pass for the rune at p.
                p = n + size
        }
        return n, err
}

func (t *cond) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
        p := 0
        for nSrc < len(src) && err == nil {
                // Don't process too much at a time, as the work might be wasted if the
                // destination buffer isn't large enough to hold the result or a
                // transform returns an error early.
                const maxChunk = 4096
                max := len(src)
                if n := nSrc + maxChunk; n < len(src) {
                        max = n
                }
                atEnd := false
                size := 0
                current := t.t
                for ; p < max; p += size {
                        r := rune(src[p])
                        if r < utf8.RuneSelf {
                                size = 1
                        } else if r, size = utf8.DecodeRune(src[p:]); size == 1 {
                                if !atEOF && !utf8.FullRune(src[p:]) {
                                        err = transform.ErrShortSrc
                                        break
                                }
                        }
                        if !t.check(r) {
                                // The next rune will be the start of a new run.
                                atEnd = true
                                break
                        }
                }
                nDst2, nSrc2, err2 := current.Transform(dst[nDst:], src[nSrc:p], atEnd || (atEOF && p == len(src)))
                nDst += nDst2
                nSrc += nSrc2
                if err2 != nil {
                        return nDst, nSrc, err2
                }
                // At this point either err != nil or t.check will pass for the rune at p.
                p = nSrc + size
        }
        return nDst, nSrc, err
}