use result cache (#30)

Author: AsaiYusuke

buffer_container.go

@@ -1,38 +1,5 @@
 package jsonpath
 
-import (
-	"sort"
-	"sync"
-)
-
 type bufferContainer struct {
 	result []interface{}
 }
-
-var bufferContainerSortSliceSyncPool = &sync.Pool{
-	New: func() interface{} { return new(sort.StringSlice) },
-}
-
-func (b *bufferContainer) getSortedKeys(srcMap map[string]interface{}) *sort.StringSlice {
-	length := len(srcMap)
-	sortKeys := bufferContainerSortSliceSyncPool.Get().(*sort.StringSlice)
-	if cap(*sortKeys) < length {
-		*sortKeys = make(sort.StringSlice, length)
-	}
-	*sortKeys = (*sortKeys)[:length]
-	index := 0
-	for key := range srcMap {
-		(*sortKeys)[index] = key
-		index++
-	}
-	if length > 1 {
-		sortKeys.Sort()
-	}
-	return sortKeys
-}
-
-func (b *bufferContainer) putSortSlice(sortKeys *sort.StringSlice) {
-	if sortKeys != nil {
-		bufferContainerSortSliceSyncPool.Put(sortKeys)
-	}
-}

cache.go

@@ -0,0 +1,47 @@
+package jsonpath
+
+import (
+	"sort"
+	"sync"
+)
+
+var sortSliceSyncPool = &sync.Pool{
+	New: func() interface{} { return new(sort.StringSlice) },
+}
+
+var resultSyncPool = &sync.Pool{
+	New: func() interface{} { return new(bufferContainer) },
+}
+
+func getSortedKeys(srcMap map[string]interface{}) *sort.StringSlice {
+	length := len(srcMap)
+	sortKeys := sortSliceSyncPool.Get().(*sort.StringSlice)
+	if cap(*sortKeys) < length {
+		*sortKeys = make(sort.StringSlice, length)
+	}
+	*sortKeys = (*sortKeys)[:length]
+	index := 0
+	for key := range srcMap {
+		(*sortKeys)[index] = key
+		index++
+	}
+	if length > 1 {
+		sortKeys.Sort()
+	}
+	return sortKeys
+}
+
+func putSortSlice(sortKeys *sort.StringSlice) {
+	if sortKeys != nil {
+		sortSliceSyncPool.Put(sortKeys)
+	}
+}
+
+func getContainer() *bufferContainer {
+	return resultSyncPool.Get().(*bufferContainer)
+}
+
+func putContainer(container *bufferContainer) {
+	container.result = container.result[:0]
+	resultSyncPool.Put(container)
+}

jsonpath.go

@@ -52,13 +52,21 @@ func Parse(jsonPath string, config ...Config) (f func(src interface{}) ([]interf
 
 	root := parser.jsonPathParser.root
 	return func(src interface{}) ([]interface{}, error) {
-		container := bufferContainer{}
+		container := getContainer()
+		defer func() {
+			putContainer(container)
+		}()
 
-		err := root.retrieve(src, src, &container)
-		if err != nil {
-			return container.result, err.(error)
+		if err := root.retrieve(src, src, container); err != nil {
+			return nil, err.(error)
 		}
-		return container.result, nil
+
+		result := make([]interface{}, len(container.result))
+		for index := range result {
+			result[index] = container.result[index]
+		}
+
+		return result, nil
 
 	}, nil
 }

syntax_node_function_aggregate.go

@@ -10,19 +10,23 @@ type syntaxAggregateFunction struct {
 func (f *syntaxAggregateFunction) retrieve(
 	root, current interface{}, container *bufferContainer) errorRuntime {
 
-	values := bufferContainer{}
+	values := getContainer()
+	defer func() {
+		putContainer(values)
+	}()
 
-	if err := f.param.retrieve(root, current, &values); err != nil {
+	if err := f.param.retrieve(root, current, values); err != nil {
 		return err
 	}
 
+	result := values.result
 	if !f.param.isValueGroup() {
 		if arrayParam, ok := values.result[0].([]interface{}); ok {
-			values.result = arrayParam
+			result = arrayParam
 		}
 	}
 
-	filteredValue, err := f.function(values.result)
+	filteredValue, err := f.function(result)
 	if err != nil {
 		return ErrorFunctionFailed{
 			errorBasicRuntime: f.errorRuntime,

syntax_node_identifier_child_wildcard.go

@@ -37,7 +37,7 @@ func (i *syntaxChildWildcardIdentifier) retrieveMap(
 	var deepestTextLen int
 	var deepestError errorRuntime
 
-	sortKeys := container.getSortedKeys(srcMap)
+	sortKeys := getSortedKeys(srcMap)
 
 	for _, key := range *sortKeys {
 		if err := i.retrieveMapNext(root, srcMap, key, container); err != nil {
@@ -47,7 +47,7 @@ func (i *syntaxChildWildcardIdentifier) retrieveMap(
 		}
 	}
 
-	container.putSortSlice(sortKeys)
+	putSortSlice(sortKeys)
 
 	if len(container.result) > 0 {
 		return nil

syntax_node_identifier_recursive_child.go

@@ -47,7 +47,7 @@ func (i *syntaxRecursiveChildIdentifier) retrieve(
 				}
 			}
 
-			sortKeys := container.getSortedKeys(typedNodes)
+			sortKeys := getSortedKeys(typedNodes)
 			for index := len(typedNodes) - 1; index >= 0; index-- {
 				node := typedNodes[(*sortKeys)[index]]
 				switch node.(type) {
@@ -56,7 +56,7 @@ func (i *syntaxRecursiveChildIdentifier) retrieve(
 				}
 			}
 
-			container.putSortSlice(sortKeys)
+			putSortSlice(sortKeys)
 
 		case []interface{}:
 			if i.nextListRequired {

syntax_node_qualifier_filter.go

@@ -37,7 +37,7 @@ func (f *syntaxFilterQualifier) retrieveMap(
 	var deepestTextLen int
 	var deepestError errorRuntime
 
-	sortKeys := container.getSortedKeys(srcMap)
+	sortKeys := getSortedKeys(srcMap)
 
 	valueList := make([]interface{}, len(*sortKeys))
 	for index := range *sortKeys {
@@ -69,7 +69,7 @@ func (f *syntaxFilterQualifier) retrieveMap(
 		}
 	}
 
-	container.putSortSlice(sortKeys)
+	putSortSlice(sortKeys)
 
 	if len(container.result) > 0 {
 		return nil

syntax_query_param_current_root.go

@@ -12,23 +12,29 @@ func (e *syntaxQueryParamCurrentRoot) compute(
 	root interface{}, currentList []interface{}) []interface{} {
 
 	result := make([]interface{}, len(currentList))
-	containers := make([]bufferContainer, len(currentList))
 
 	var hasValue bool
+
+	container := getContainer()
+	defer func() {
+		putContainer(container)
+	}()
+
 	for index := range currentList {
-		if e.param.retrieve(root, currentList[index], &containers[index]) != nil {
+		container.result = container.result[:0]
+		if e.param.retrieve(root, currentList[index], container) != nil {
 			result[index] = emptyEntity
 			continue
 		}
 		hasValue = true
-		if e.param.isValueGroup() {
-			result[index] = containers[index].result
-		} else {
-			result[index] = containers[index].result[0]
-		}
+		// If e.param.isValueGroup==true,
+		// Only the first element is returned because it is an existence check.
+		result[index] = container.result[0]
 	}
+
 	if hasValue {
 		return result
 	}
+
 	return emptyList
 }

syntax_query_param_root.go

@@ -11,9 +11,12 @@ func (e *syntaxQueryParamRoot) isValueGroupParameter() bool {
 func (e *syntaxQueryParamRoot) compute(
 	root interface{}, currentList []interface{}) []interface{} {
 
-	values := bufferContainer{}
+	values := getContainer()
+	defer func() {
+		putContainer(values)
+	}()
 
-	if e.param.retrieve(root, root, &values) != nil {
+	if e.param.retrieve(root, root, values) != nil {
 		return emptyList
 	}