github.com/altipla-consulting/ravendb-go-client@v0.1.3/compare_exchange_value_result_parser.go (about)

     1  package ravendb
     2  
     3  import (
     4  	"reflect"
     5  )
     6  
     7  func compareExchangeValueResultParserGetValues(clazz reflect.Type, response []byte, conventions *DocumentConventions) (map[string]*CompareExchangeValue, error) {
     8  	var jsonResponse map[string]interface{}
     9  	err := jsonUnmarshal(response, &jsonResponse)
    10  	if err != nil {
    11  		return nil, err
    12  	}
    13  
    14  	results := make(map[string]*CompareExchangeValue)
    15  
    16  	itemsI, ok := jsonResponse["Results"]
    17  	if !ok {
    18  		return nil, newIllegalStateError("Response is invalid. Results is missing.")
    19  	}
    20  	items, ok := itemsI.([]interface{})
    21  	if !ok {
    22  		return nil, newIllegalStateError("Response is invalid. Results is missing.")
    23  	}
    24  
    25  	for _, itemI := range items {
    26  		if itemI == nil {
    27  			return nil, newIllegalStateError("Response is invalid. Item is null")
    28  		}
    29  		item, ok := itemI.(map[string]interface{})
    30  		if !ok {
    31  			return nil, newIllegalStateError("Response is invalid. Item is null")
    32  		}
    33  		key, ok := jsonGetAsString(item, "Key")
    34  		if !ok {
    35  			return nil, newIllegalStateError("Response is invalid. Key is missing.")
    36  		}
    37  		index, ok := jsonGetAsInt64(item, "Index")
    38  
    39  		if !ok {
    40  			return nil, newIllegalStateError("Response is invalid. Index is missing")
    41  		}
    42  
    43  		raw, ok := item["Value"]
    44  		if !ok || raw == nil {
    45  			return nil, newIllegalStateError("Response is invalid. Value is missing.")
    46  		}
    47  		rawMap, ok := raw.(map[string]interface{})
    48  		if !ok {
    49  			return nil, newIllegalStateError("Response is invalid. Value is missing.")
    50  		}
    51  
    52  		if isTypePrimitive(clazz) {
    53  			var value interface{}
    54  			rawValue := rawMap["Object"]
    55  			value, err = convertValue(rawValue, clazz)
    56  			if err != nil {
    57  				return nil, err
    58  			}
    59  			cmpValue := NewCompareExchangeValue(key, index, value)
    60  			results[key] = cmpValue
    61  		} else {
    62  			object, ok := rawMap["Object"]
    63  			if !ok || object == nil {
    64  				v := NewCompareExchangeValue(key, index, getDefaultValueForType(clazz))
    65  				results[key] = v
    66  			} else {
    67  				converted, err := convertValue(object, clazz)
    68  				if err != nil {
    69  					return nil, err
    70  				}
    71  				v := NewCompareExchangeValue(key, index, converted)
    72  				results[key] = v
    73  			}
    74  		}
    75  	}
    76  
    77  	return results, nil
    78  }
    79  
    80  func compareExchangeValueResultParserGetValue(clazz reflect.Type, response []byte, conventions *DocumentConventions) (*CompareExchangeValue, error) {
    81  	if response == nil {
    82  		return nil, nil
    83  	}
    84  
    85  	values, err := compareExchangeValueResultParserGetValues(clazz, response, conventions)
    86  	if err != nil {
    87  		return nil, err
    88  	}
    89  	if len(values) == 0 {
    90  		return nil, nil
    91  	}
    92  	// Note: in Go iteration order is random, so this might behave
    93  	// differently than Java
    94  	for _, v := range values {
    95  		return v, nil
    96  	}
    97  	panicIf(true, "Should never be reached")
    98  	return nil, nil
    99  }