github.com/viant/toolbox@v0.34.5/data/helper.go (about)

     1  package data
     2  
     3  import (
     4  	"fmt"
     5  	"github.com/viant/toolbox"
     6  	"reflect"
     7  	"sort"
     8  	"strings"
     9  	"unicode"
    10  )
    11  
    12  func ExtractPath(expression string) string {
    13  	var result = ""
    14  	for _, r := range expression {
    15  		aChar := string(r)
    16  		if unicode.IsLetter(r) || unicode.IsDigit(r) || aChar == "[" || aChar == "]" || aChar == "." || aChar == "_" || aChar == "{" || aChar == "}" {
    17  			result += aChar
    18  		}
    19  	}
    20  	return strings.Trim(result, "{}")
    21  }
    22  
    23  func recordToMap(fields []*Field, record []interface{}, aMap map[string]interface{}) {
    24  	for _, field := range fields {
    25  		index := field.index
    26  		var value = record[index]
    27  		if value == nil {
    28  			continue
    29  		}
    30  		aMap[field.Name] = value
    31  	}
    32  }
    33  
    34  func indexValue(indexBy []int, record []interface{}) interface{} {
    35  	if len(indexBy) == 1 {
    36  		return record[indexBy[0]]
    37  	}
    38  	var values = make([]string, len(indexBy))
    39  	for i, fieldIndex := range indexBy {
    40  		values[i] = toolbox.AsString(record[fieldIndex])
    41  	}
    42  	return strings.Join(values, "-")
    43  }
    44  
    45  func intsToGenericSlice(keyType reflect.Type, aSlice []int) []interface{} {
    46  	var result = make([]interface{}, len(aSlice))
    47  	for i, item := range aSlice {
    48  		result[i] = reflect.ValueOf(item).Convert(keyType).Interface()
    49  	}
    50  	return result
    51  }
    52  
    53  func floatsToGenericSlice(keyType reflect.Type, aSlice []float64) []interface{} {
    54  	var result = make([]interface{}, len(aSlice))
    55  	for i, item := range aSlice {
    56  		result[i] = reflect.ValueOf(item).Convert(keyType).Interface()
    57  	}
    58  	return result
    59  }
    60  
    61  func stringsToGenericSlice(aSlice []string) []interface{} {
    62  	var result = make([]interface{}, len(aSlice))
    63  	for i, item := range aSlice {
    64  		result[i] = toolbox.AsString(item)
    65  	}
    66  	return result
    67  }
    68  
    69  func sortKeys(key interface{}, aMap map[interface{}][]interface{}) ([]interface{}, error) {
    70  	if len(aMap) == 0 {
    71  		return []interface{}{}, nil
    72  	}
    73  	var i = 0
    74  	switch key.(type) {
    75  	case int, uint, uint8, uint16, uint32, uint64, int8, int16, int32, int64:
    76  		var aSlice = make([]int, len(aMap))
    77  		for k := range aMap {
    78  			aSlice[i] = toolbox.AsInt(k)
    79  			i++
    80  		}
    81  		sort.Ints(aSlice)
    82  		return intsToGenericSlice(reflect.TypeOf(key), aSlice), nil
    83  	case float64, float32:
    84  		var aSlice = make([]float64, len(aMap))
    85  		for k := range aMap {
    86  			aSlice[i] = toolbox.AsFloat(k)
    87  			i++
    88  		}
    89  		sort.Float64s(aSlice)
    90  		return floatsToGenericSlice(reflect.TypeOf(key), aSlice), nil
    91  	case string:
    92  		var aSlice = make([]string, len(aMap))
    93  		for k := range aMap {
    94  			aSlice[i] = toolbox.AsString(k)
    95  			i++
    96  		}
    97  		sort.Strings(aSlice)
    98  		return stringsToGenericSlice(aSlice), nil
    99  	}
   100  	return nil, fmt.Errorf("unable sort, unsupported type: %T", key)
   101  }