Source file src/pkg/vendor/golang.org/x/text/unicode/norm/readwriter.go

     1	// Copyright 2011 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package norm
     6	
     7	import "io"
     8	
     9	type normWriter struct {
    10		rb  reorderBuffer
    11		w   io.Writer
    12		buf []byte
    13	}
    14	
    15	// Write implements the standard write interface.  If the last characters are
    16	// not at a normalization boundary, the bytes will be buffered for the next
    17	// write. The remaining bytes will be written on close.
    18	func (w *normWriter) Write(data []byte) (n int, err error) {
    19		// Process data in pieces to keep w.buf size bounded.
    20		const chunk = 4000
    21	
    22		for len(data) > 0 {
    23			// Normalize into w.buf.
    24			m := len(data)
    25			if m > chunk {
    26				m = chunk
    27			}
    28			w.rb.src = inputBytes(data[:m])
    29			w.rb.nsrc = m
    30			w.buf = doAppend(&w.rb, w.buf, 0)
    31			data = data[m:]
    32			n += m
    33	
    34			// Write out complete prefix, save remainder.
    35			// Note that lastBoundary looks back at most 31 runes.
    36			i := lastBoundary(&w.rb.f, w.buf)
    37			if i == -1 {
    38				i = 0
    39			}
    40			if i > 0 {
    41				if _, err = w.w.Write(w.buf[:i]); err != nil {
    42					break
    43				}
    44				bn := copy(w.buf, w.buf[i:])
    45				w.buf = w.buf[:bn]
    46			}
    47		}
    48		return n, err
    49	}
    50	
    51	// Close forces data that remains in the buffer to be written.
    52	func (w *normWriter) Close() error {
    53		if len(w.buf) > 0 {
    54			_, err := w.w.Write(w.buf)
    55			if err != nil {
    56				return err
    57			}
    58		}
    59		return nil
    60	}
    61	
    62	// Writer returns a new writer that implements Write(b)
    63	// by writing f(b) to w. The returned writer may use an
    64	// internal buffer to maintain state across Write calls.
    65	// Calling its Close method writes any buffered data to w.
    66	func (f Form) Writer(w io.Writer) io.WriteCloser {
    67		wr := &normWriter{rb: reorderBuffer{}, w: w}
    68		wr.rb.init(f, nil)
    69		return wr
    70	}
    71	
    72	type normReader struct {
    73		rb           reorderBuffer
    74		r            io.Reader
    75		inbuf        []byte
    76		outbuf       []byte
    77		bufStart     int
    78		lastBoundary int
    79		err          error
    80	}
    81	
    82	// Read implements the standard read interface.
    83	func (r *normReader) Read(p []byte) (int, error) {
    84		for {
    85			if r.lastBoundary-r.bufStart > 0 {
    86				n := copy(p, r.outbuf[r.bufStart:r.lastBoundary])
    87				r.bufStart += n
    88				if r.lastBoundary-r.bufStart > 0 {
    89					return n, nil
    90				}
    91				return n, r.err
    92			}
    93			if r.err != nil {
    94				return 0, r.err
    95			}
    96			outn := copy(r.outbuf, r.outbuf[r.lastBoundary:])
    97			r.outbuf = r.outbuf[0:outn]
    98			r.bufStart = 0
    99	
   100			n, err := r.r.Read(r.inbuf)
   101			r.rb.src = inputBytes(r.inbuf[0:n])
   102			r.rb.nsrc, r.err = n, err
   103			if n > 0 {
   104				r.outbuf = doAppend(&r.rb, r.outbuf, 0)
   105			}
   106			if err == io.EOF {
   107				r.lastBoundary = len(r.outbuf)
   108			} else {
   109				r.lastBoundary = lastBoundary(&r.rb.f, r.outbuf)
   110				if r.lastBoundary == -1 {
   111					r.lastBoundary = 0
   112				}
   113			}
   114		}
   115	}
   116	
   117	// Reader returns a new reader that implements Read
   118	// by reading data from r and returning f(data).
   119	func (f Form) Reader(r io.Reader) io.Reader {
   120		const chunk = 4000
   121		buf := make([]byte, chunk)
   122		rr := &normReader{rb: reorderBuffer{}, r: r, inbuf: buf}
   123		rr.rb.init(f, buf)
   124		return rr
   125	}
   126	

View as plain text