FIx: Slow decode by reducing comparisions

Author: akshaybharambe14

jsonc.go

@@ -1,3 +1,11 @@
+// package jsonc provides APIs to read commented (.jsonc) files.
+// It implements io.Reader which makes it compatible with standard library.
+
+// EX.
+// 		...
+// 		ba, _ := ioutil.Readall(jsonc.NewDecoder(r)) // r is io.Reader
+// 		...
+
 package jsonc
 
 import (
@@ -8,19 +16,27 @@ import (
 )
 
 type (
-	state int
+	// Decoder represents a .jsonc decoder. It implements io.Reader.
+	Decoder struct {
+		r io.Reader
+		c comment
+	}
 
+	// comment represents status of Decoder while reading json document.
 	comment struct {
 		state   state
-		multiLn bool
-		isJSON  bool
+		multiLn bool // if true, a multiline comment
+		isJSON  bool // if true, decoder is processing either a "key" or "value"
 	}
 
-	// Decoder implements io.Reader. It wraps provided source.
-	Decoder struct {
-		r io.Reader
-		c comment
-	}
+	state int
+)
+
+const (
+	stopped  state = iota // 0, default state, started with 0 to make `zero value` of `comment` useful.
+	canStart              // 1
+	started               // 2
+	canStop               // 3
 )
 
 const (
@@ -35,118 +51,107 @@ const (
 	charN    = 110 // (n)
 )
 
-const (
-	stopped  state = iota // 0, default state
-	canStart              // 1
-	started               // 2
-	canStop               // 3
-)
-
 var (
 	ErrUnexpectedEndOfComment = errors.New("unexpected end of comment")
 )
 
-// NewDecoder returns a new Decoder wrapping the provided io.Reader. The returned decoder implements io.Reader.
-func NewDecoder(r io.Reader) *Decoder {
-	return &Decoder{
-		c: comment{},
-		r: r,
-	}
+func (c *comment) reset() {
+	c.state = stopped
+	c.multiLn = false
 }
 
-// Read reads from underlying reader and processes the stream to omit comments.
-// A single read doesn't guaranttee a valid JSON. Depends on length of passed slice.
-//
-// Produces ErrUnexpectedEndOfComment for incomplete comments.
-func (d *Decoder) Read(p []byte) (int, error) {
-
-	n, err := d.r.Read(p)
-	if err != nil {
-		return 0, err
-	}
-
-	shortRead := n <= len(p)
-	n = decode(p[:n], &d.c)
-
-	if shortRead && !d.c.complete() {
-		return 0, ErrUnexpectedEndOfComment
-	}
-
-	return n, nil
+func (c *comment) complete() bool {
+	return c.state == stopped
 }
 
 func decode(p []byte, c *comment) int {
 	i := 0
 	for _, s := range p {
-		if c.handle(s) {
-			p[i] = s
-			i++
-		}
-	}
 
-	return i
-}
+		switch c.state {
 
-// handle the current byte, if returned true, add the byte to result.
-func (c *comment) handle(s byte) bool {
-	switch c.state {
+		case stopped:
+			if s == quote { // all characters between "" are valid, can be added to result
+				c.isJSON = !c.isJSON
+			}
 
-	case stopped:
-		if s == quote { // all characters between "" are valid, can be added to result
-			c.isJSON = !c.isJSON
-		}
+			if c.isJSON {
+				p[i] = s
+				i++
+				continue
+			}
 
-		if c.isJSON {
-			return true
-		}
+			// TODO: formatting can be preserved by allowing space and tab in JSON
+			if s == space || s == tab || s == newLine {
+				continue
+			}
 
-		if s == space || s == tab || s == newLine {
-			return false
-		}
+			if s == fwdSlash {
+				c.state = canStart
+				continue
+			}
 
-		if s == fwdSlash {
-			c.state = canStart
-			return false
-		}
+			p[i] = s
+			i++
 
-		return true
+		case canStart:
 
-	case canStart:
+			if s == star || s == fwdSlash {
+				c.state = started
+			}
 
-		if s == star || s == fwdSlash {
-			c.state = started
-		}
+			c.multiLn = (s == star)
 
-		c.multiLn = (s == star)
+		case started:
 
-	case started:
+			if s == star || s == bkdSlash {
+				c.state = canStop
+			}
 
-		if s == star || s == bkdSlash {
-			c.state = canStop
-		}
+			if s == newLine && !c.multiLn {
+				c.reset()
+			}
 
-		if s == newLine && !c.multiLn {
-			c.reset()
-		}
+		case canStop:
 
-	case canStop:
+			if s == fwdSlash || s == charN {
+				c.reset()
+			}
 
-		if s == fwdSlash || s == charN {
-			c.reset()
 		}
 
 	}
 
-	return false
+	return i
 }
 
-func (c *comment) reset() {
-	c.state = stopped
-	c.multiLn = false
+// NewDecoder returns a new Decoder wrapping the provided io.Reader.
+func NewDecoder(r io.Reader) *Decoder {
+	return &Decoder{
+		c: comment{},
+		r: r,
+	}
 }
 
-func (c *comment) complete() bool {
-	return c.state == stopped
+// Read reads from underlying reader and processes the stream to omit comments.
+// A single read doesn't guaranttee a valid JSON. Depends on length of passed slice.
+//
+// Produces ErrUnexpectedEndOfComment for incomplete comments else if not nil, then it is an error from underlying reader.
+func (d *Decoder) Read(p []byte) (int, error) {
+
+	n, err := d.r.Read(p)
+	if err != nil {
+		return 0, err
+	}
+
+	shortRead := n <= len(p) // data to be processed is less than length of `p`
+	n = decode(p[:n], &d.c)
+
+	if shortRead && !d.c.complete() {
+		return 0, ErrUnexpectedEndOfComment
+	}
+
+	return n, nil
 }
 
 // DecodeBytes decodes passed commented json byte slice to normal json.