github.com/TIBCOSoftware/flogo-lib@v0.5.9/core/mapper/object.go (about)

     1  package mapper
     2  
     3  import (
     4  	"errors"
     5  	"strings"
     6  
     7  	"github.com/TIBCOSoftware/flogo-lib/core/data"
     8  	"github.com/TIBCOSoftware/flogo-lib/core/mapper/exprmapper"
     9  )
    10  
    11  func MapObject(mappingObject interface{}, scope data.Scope, resolver data.Resolver) (result interface{}, err error) {
    12  
    13  	complexObject, ok := mappingObject.(data.ComplexObject)
    14  
    15  	if ok {
    16  		mappingObject = complexObject.Value
    17  	}
    18  
    19  	switch t := mappingObject.(type) {
    20  	case map[string]interface{}:
    21  		return dm(t, scope, resolver)
    22  	case []interface{}:
    23  		return da(t, scope, resolver)
    24  	default:
    25  		return nil, errors.New("unsupported mapping object")
    26  	}
    27  }
    28  
    29  func dm(mappingObject map[string]interface{}, scope data.Scope, resolver data.Resolver) (result map[string]interface{}, err error) {
    30  
    31  	result = make(map[string]interface{}, len(mappingObject))
    32  
    33  	for key, value := range mappingObject {
    34  
    35  		switch t := value.(type) {
    36  		case string:
    37  
    38  			if strings.HasPrefix(t, "{{") {
    39  				result[key], err = evalExpr(t, scope, resolver)
    40  			} else {
    41  				result[key] = t
    42  			}
    43  		case map[string]interface{}:
    44  			result[key], err = dm(t, scope, resolver)
    45  		case []interface{}:
    46  			result[key], err = da(t, scope, resolver)
    47  		default:
    48  			result[key] = t
    49  		}
    50  	}
    51  
    52  	return result, err
    53  }
    54  
    55  func da(mappingArr []interface{}, scope data.Scope, resolver data.Resolver) (result []interface{}, err error) {
    56  
    57  	result = make([]interface{}, len(mappingArr))
    58  
    59  	for idx, value := range mappingArr {
    60  
    61  		switch t := value.(type) {
    62  		case string:
    63  
    64  			if strings.HasPrefix(t, "{{") {
    65  				result[idx], err = evalExpr(t, scope, resolver)
    66  			} else {
    67  				result[idx] = t
    68  			}
    69  		case map[string]interface{}:
    70  			result[idx], err = dm(t, scope, resolver)
    71  		case []interface{}:
    72  			result[idx], err = da(t, scope, resolver)
    73  		default:
    74  			result[idx] = t
    75  		}
    76  	}
    77  
    78  	return result, err
    79  }
    80  
    81  func evalExpr(exprString string, scope data.Scope, resolver data.Resolver) (interface{}, error) {
    82  
    83  	exprStr := exprString[2 : len(exprString)-2]
    84  	//support just assign for now
    85  	//todo: optimization - trim whitspace when first creating object mapping
    86  	return exprmapper.GetExpresssionValue(strings.TrimSpace(exprStr), scope, resolver)
    87  }