Improve unmarshmaling

benchmark/benchmark_large_payload_test.go

@@ -35,25 +35,47 @@ func BenchmarkJsonParserLarge(b *testing.B) {
 	}
 }
 
-func BenchmarkJsonParserLargeOffsets(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		r := largeFixture
-		offsets := jsonparser.KeyOffsets(r,
-			[]string{"users"},
-			[]string{"topics", "topics"},
-		)
 
-		jsonparser.ArrayEach(r[offsets[0]:], func(value []byte, dataType int, offset int, err error) {
-			jsonparser.Get(value, "username")
-			nothing()
-		})
+func BenchmarkJsonParserOffsetsLarge(b *testing.B) {
+	keys := [][]string{
+		[]string{"users"},
+		[]string{"topics", "topics"},
+	}
 
-		jsonparser.ArrayEach(r[offsets[1]:], func(value []byte, dataType int, offset int, err error) {
-			aOff := jsonparser.KeyOffsets(value, []string{"id"}, []string{"slug"})
-			jsonparser.GetInt(value[aOff[0]:])
-			jsonparser.Get(value[aOff[1]:])
-			nothing()
-		})
+	nestedKeys := [][]string{
+		[]string{"id"},
+		[]string{"slug"},
+	}
+
+	for i := 0; i < b.N; i++ {
+		r := largeFixture
+		jsonparser.KeyEach(r, func (idx int, value []byte) (offset int) {
+			switch idx {
+			case 0: // users
+				aOff, _ := jsonparser.ArrayEach(value, func(value []byte, dataType int, offset int, err error) {
+					jsonparser.Get(value, "username")
+					nothing()
+				})
+				return aOff
+			case 1: // topics
+				aOff, _ := jsonparser.ArrayEach(value, func(value []byte, dataType int, offset int, err error) {
+					jsonparser.KeyEach(value, func(nidx int, value []byte)(offset int) {
+						v, _, of, _ := jsonparser.Get(value)
+						panic(string(v))
+						switch nidx {
+						case 0:
+							jsonparser.ParseInt(v)
+						case 1:
+							nothing(v)
+						}
+
+						return of
+					}, nestedKeys...)
+				})
+				return aOff
+			}
+			return
+		}, keys...)
 	}
 }
 

benchmark/benchmark_medium_payload_test.go

@@ -34,39 +34,49 @@ func BenchmarkJsonParserMedium(b *testing.B) {
 	}
 }
 
-func BenchmarkJsonParserMediumOffsets(b *testing.B) {
+func BenchmarkJsonParserOffsetsMedium(b *testing.B) {
+	keys := [][]string{
+		[]string{"person", "name", "fullName"},
+		[]string{"person", "github", "followers"},
+		[]string{"company"},
+		[]string{"person", "gravatar", "avatars"},
+	}
+
 	for i := 0; i < b.N; i++ {
 		r := mediumFixture
-		offsets := jsonparser.KeyOffsets(r,
-			[]string{"person", "name", "fullName"},
-			[]string{"person", "github", "followers"},
-			[]string{"company"},
-			[]string{"person", "gravatar", "avatars"},
-		)
-
-		jsonparser.Get(r[offsets[0]:])
-		jsonparser.GetInt(r[offsets[1]:])
-		jsonparser.Get(r[offsets[2]:])
-
-		jsonparser.ArrayEach(r[offsets[3]:], func(value []byte, dataType int, offset int, err error) {
-			jsonparser.GetUnsafeString(value, "url")
-			nothing()
-		})
+		jsonparser.KeyEach(r, func (idx int, value []byte) (offset int) {
+			v, _, offset, _ := jsonparser.Get(value)
+
+			switch idx {
+			case 0: // fullName
+				nothing(v)
+			case 1: // followers
+				jsonparser.ParseInt(value)
+			case 2: // company
+				jsonparser.Get(value)
+			case 3: // Processing array
+				aOff, _ := jsonparser.ArrayEach(value, func(value []byte, dataType int, offset int, err error) {
+					jsonparser.Get(value, "url")
+				})
+				offset += aOff
+			}
+			return
+		}, keys...)
 	}
 }
 
-// func BenchmarkJsonParserMediumStruct(b *testing.B) {
-// 	for i := 0; i < b.N; i++ {
-// 		var data MediumPayload
-// 		jsonparser.Unmarshal(mediumFixture, &data)
+func BenchmarkJsonParserStructMedium(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		var data MediumPayload
+		jsonparser.Unmarshal(mediumFixture, &data)
 
-// 		nothing(data.Person.Name.FullName, data.Person.Github.Followers, data.Company)
+		nothing(data.Person.Name.FullName, data.Person.Github.Followers, data.Company)
 
-// 		for _, el := range data.Person.Gravatar.Avatars {
-// 			nothing(el.Url)
-// 		}
-// 	}
-// }
+		for _, el := range data.Person.Gravatar.Avatars {
+			nothing(el.Url)
+		}
+	}
+}
 
 
 /*

encode.go

@@ -17,9 +17,62 @@ func init() {
     cache = make(map[string]*structCache)
 }
 
-func Unmarshal(data []byte, v interface{}) error {
-    val := reflect.ValueOf(v).Elem()
+func unmarshalValue(data []byte, val reflect.Value) int {
+   if !val.IsValid() || !val.CanSet() {
+        return 0
+    }
+
+    v, dt, of, err := Get(data)
+
+    switch val.Kind() {
+    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+        if dt == Number && err == nil {
+            val.SetInt(ParseInt(v))
+        }
+    case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+        if dt == Number && err == nil {
+            val.SetUint(uint64(ParseInt(v)))
+        }
+    case reflect.String:
+        if dt == String && err == nil {
+            val.SetString(unsafeBytesToString(v))
+        }
+    case reflect.Bool:
+        if dt == Boolean && err == nil {
+            val.SetBool(ParseBoolean(v))
+        }
+    case reflect.Ptr:
+        obj := reflect.New(val.Type().Elem())
+        unmarshalValue(v, obj.Elem())
+        val.Set(obj)
+    case reflect.Struct:
+        obj := reflect.New(val.Type())
+        unmarshalStruct(v, obj.Elem())
+        val.Set(obj.Elem())
+    case reflect.Slice:
+        sT := val.Type().Elem()
+        s := reflect.MakeSlice(val.Type(), 0, 0)
+        ArrayEach(v, func(value []byte, dataType int, offset int, err error){
+            el := reflect.New(sT)
+
+            switch sT.Kind() {
+            case reflect.Struct:
+                unmarshalStruct(value, el.Elem())
+            case reflect.Ptr:
+                unmarshalValue(value, el.Elem())
+            default:
+                unmarshalValue(value, el.Elem())
+            }
+
+            s = reflect.Append(s, el.Elem())
+        })
+        val.Set(s)
+    }
+
+    return of
+}
 
+func unmarshalStruct(data []byte, val reflect.Value) int {
     sName := val.Type().Name()
     var sCache *structCache
     var ok bool
@@ -28,58 +81,43 @@ func Unmarshal(data []byte, v interface{}) error {
     if sCache, ok = cache[sName]; !ok {
         count := val.NumField()
         fields := make([][]string, count)
-        fieldTypes := make([]reflect.Kind, count)
+        // fieldTypes := make([]reflect.Kind, count)
 
         for i := 0; i < val.NumField(); i++ {
-            valueField := val.Field(i)
+            // valueField := val.Field(i)
             typeField := val.Type().Field(i)
             tag := typeField.Tag
             jsonKey := tag.Get("json")
 
             if jsonKey != "" {
                 fields[i] = []string{jsonKey}
             } else {
-                fields[i] = []string{strings.ToLower(typeField.Name)}
+                fields[i] = []string{strings.ToLower(string(typeField.Name[:1])) + string(typeField.Name[1:])}
             }
-            fieldTypes[i] = valueField.Kind()
+            // fieldTypes[i] = valueField.Kind()
         }
 
-        sCache = &structCache{fields, fieldTypes}
+        sCache = &structCache{fields: fields}
         cache[sName] = sCache
     }
 
     fields := sCache.fields
-    fieldTypes := sCache.fieldTypes
+    // fieldTypes := sCache.fieldTypes
 
-    KeyEach(data, func(i int, d []byte) int {
+    offset := KeyEach(data, func(i int, d []byte) int {
         f := val.Field(i)
-        if !f.IsValid() || !f.CanSet() {
-            return 0
-        }
 
-        v, dt, of, err := Get(d)
+        return unmarshalValue(d, f)
+    }, fields...)
+    // panic(string(data))
 
-        switch fieldTypes[i] {
-        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-            if dt == Number && err == nil {
-                f.SetInt(ParseInt(v))
-            }
-        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-            if dt == Number && err == nil {
-                f.SetUint(uint64(ParseInt(v)))
-            }
-        case reflect.String:
-            if dt == String && err == nil {
-                f.SetString(unsafeBytesToString(v))
-            }
-        case reflect.Bool:
-            if dt == Boolean && err == nil {
-                f.SetBool(ParseBoolean(v))
-            }
-        }
+    return offset
+}
 
-        return of
-    }, fields...)
+func Unmarshal(data []byte, v interface{}) error {
+    val := reflect.ValueOf(v).Elem()
+
+    unmarshalStruct(data, val)
 
     return nil
 }