Fixed some lint errors; renamed util functions

Author: bminer

schemer.go

@@ -510,24 +510,25 @@ func DecodeSchemaJSON(r io.Reader) (Schema, error) {
 			}
 
 			return s, nil
-		} else {
-			s := &VarArraySchema{}
-			s.SetNullable(nullable)
+		}
 
-			// process the array element
-			tmp, err := json.Marshal(fields["element"])
-			if err != nil {
-				return nil, err
-			}
+		// array length not present
+		s := &VarArraySchema{}
+		s.SetNullable(nullable)
 
-			s.Element, err = DecodeSchemaJSON(bytes.NewReader(tmp))
-			if err != nil {
-				return nil, err
-			}
+		// process the array element
+		tmp, err := json.Marshal(fields["element"])
+		if err != nil {
+			return nil, err
+		}
 
-			return s, nil
+		s.Element, err = DecodeSchemaJSON(bytes.NewReader(tmp))
+		if err != nil {
+			return nil, err
 		}
 
+		return s, nil
+
 	case "object":
 		fieldsI, ok := fields["fields"]
 
@@ -849,10 +850,9 @@ func PreEncode(w io.Writer, v *reflect.Value, nullable bool) (bool, error) {
 			// 1 indicates null
 			w.Write([]byte{1})
 			return true, nil
-		} else {
-			// 0 indicates not null
-			w.Write([]byte{0})
 		}
+		// 0 indicates not null
+		w.Write([]byte{0})
 	} else if isNil {
 		return false, fmt.Errorf("cannot encode nil value: schema is not nullable")
 	}
@@ -894,9 +894,8 @@ func PreDecode(r io.Reader, v *reflect.Value, nullable bool) (bool, error) {
 					return true, nil
 				}
 				return false, fmt.Errorf("destination not settable")
-			} else {
-				return false, fmt.Errorf("cannot decode null value to a %s", v.Kind())
 			}
+			return false, fmt.Errorf("cannot decode null value to a %s", v.Kind())
 		}
 	}
 

util.go

@@ -31,45 +31,40 @@ func (r byter) ReadVarint() (int64, error) {
 	return binary.ReadVarint(r)
 }
 
-func VarIntFromIOReader(r io.Reader) (int64, error) {
-	b := &byter{r}
-	return binary.ReadVarint(b)
-}
-
-// ReadVarUint() returns an uint64 by reading from r
-func ReadVarUint(r io.Reader) (uint64, error) {
+// ReadUvarint reads an Uvarint from r one byte at a time
+func ReadUvarint(r io.Reader) (uint64, error) {
 
+	rb := byter{r}
 	buf := make([]byte, binary.MaxVarintLen64)
-	counter := 0
 
-	// read one byte at a a time
-	for {
-		b := make([]byte, 1)
-		_, err := io.ReadAtLeast(r, b, 1)
+	// Read first byte into `buf`
+	b, err := rb.ReadByte()
+	if err != nil {
+		return 0, err
+	}
+	buf[0] = b
+
+	// Read subsequent bytes into `buf`
+	i := 1
+	for ; b&0x80 > 0; i++ {
+		b, err = rb.ReadByte()
 		if err != nil {
 			return 0, err
 		}
-		buf[counter] = b[0]
-
-		// keep reading out bytes until no more data
-		if b[0]&128 != 128 {
-			break
-		}
-
-		counter++
+		buf[i] = b
 	}
 
 	decodedUInt, n := binary.Uvarint(buf)
-	if n != counter+1 {
+	if n != i {
 		return 0, fmt.Errorf("uvarint did not consume expected number of bytes")
 	}
 
 	return decodedUInt, nil
 
 }
 
-// WriteVarUint() writes a 64 bit unsigned integer to w
-func WriteVarUint(w io.Writer, v uint64) error {
+// WriteUvarint writes v to w as an Uvarint
+func WriteUvarint(w io.Writer, v uint64) error {
 
 	buf := make([]byte, binary.MaxVarintLen64)
 	varIntBytes := binary.PutUvarint(buf, v)

vararray.go

@@ -91,7 +91,7 @@ func (s *VarArraySchema) EncodeValue(w io.Writer, v reflect.Value) error {
 		return fmt.Errorf("VarArraySchema can only encode slices")
 	}
 
-	err = WriteVarUint(w, uint64(v.Len()))
+	err = WriteUvarint(w, uint64(v.Len()))
 	if err != nil {
 		return errors.New("cannot encode var string length as var int")
 	}
@@ -137,7 +137,7 @@ func (s *VarArraySchema) DecodeValue(r io.Reader, v reflect.Value) error {
 		return fmt.Errorf("VarArraySchema can only decode to slices")
 	}
 
-	expectedLen, err := ReadVarUint(r)
+	expectedLen, err := ReadUvarint(r)
 	if err != nil {
 		return err
 	}

varint.go

@@ -91,7 +91,7 @@ func (s *VarIntSchema) EncodeValue(w io.Writer, v reflect.Value) error {
 		if intVal < 0 {
 			uintVal = ^uintVal
 		}
-		return WriteVarUint(w, uintVal)
+		return WriteUvarint(w, uintVal)
 	case reflect.Uint:
 		fallthrough
 	case reflect.Uint8:
@@ -102,7 +102,7 @@ func (s *VarIntSchema) EncodeValue(w io.Writer, v reflect.Value) error {
 		fallthrough
 	case reflect.Uint64:
 		uintVal := v.Uint()
-		return WriteVarUint(w, uintVal)
+		return WriteUvarint(w, uintVal)
 	}
 
 	return nil
@@ -137,7 +137,7 @@ func (s *VarIntSchema) DecodeValue(r io.Reader, v reflect.Value) error {
 
 	// Decode value
 	if s.Signed {
-		uintVal, err := ReadVarUint(r)
+		uintVal, err := ReadUvarint(r)
 		if err != nil {
 			return err
 		}
@@ -220,7 +220,7 @@ func (s *VarIntSchema) DecodeValue(r io.Reader, v reflect.Value) error {
 		}
 	} else {
 		// Unsigned
-		uintVal, err := ReadVarUint(r)
+		uintVal, err := ReadUvarint(r)
 		if err != nil {
 			return err
 		}

varobject.go

@@ -126,7 +126,7 @@ func (s *VarObjectSchema) EncodeValue(w io.Writer, v reflect.Value) error {
 		return fmt.Errorf("varObjectSchema can only encode maps")
 	}
 
-	err = WriteVarUint(w, uint64(v.Len()))
+	err = WriteUvarint(w, uint64(v.Len()))
 	if err != nil {
 		return errors.New("cannot encode var string length as var int")
 	}
@@ -182,7 +182,7 @@ func (s *VarObjectSchema) DecodeValue(r io.Reader, v reflect.Value) error {
 
 	// we wrote the number of entries in the map as a var int
 	// when we did the encoding
-	expectedNumEntries, err := ReadVarUint(r)
+	expectedNumEntries, err := ReadUvarint(r)
 	if err != nil {
 		return err
 	}

varstring.go

@@ -77,7 +77,7 @@ func (s *VarStringSchema) EncodeValue(w io.Writer, v reflect.Value) error {
 	var stringToEncode string = v.String()
 	var stringLen int = len(stringToEncode)
 
-	err = WriteVarUint(w, uint64(stringLen))
+	err = WriteUvarint(w, uint64(stringLen))
 	if err != nil {
 		return errors.New("cannot encode var string length as var int")
 	}
@@ -117,7 +117,7 @@ func (s *VarStringSchema) DecodeValue(r io.Reader, v reflect.Value) error {
 		k = t.Kind()
 	}
 
-	expectedLen, err := ReadVarUint(r)
+	expectedLen, err := ReadUvarint(r)
 	if err != nil {
 		return err
 	}