github.com/christoph-karpowicz/db_mediator@v0.0.0-20210207102849-61a28a1071d8/internal/server/synch/util.go (about)

     1  package synch
     2  
     3  import (
     4  	"errors"
     5  	"reflect"
     6  )
     7  
     8  func areEqual(val1 interface{}, val2 interface{}) (bool, error) {
     9  	var val1kind reflect.Kind = reflect.TypeOf(val1).Kind()
    10  	var val2kind reflect.Kind = reflect.TypeOf(val2).Kind()
    11  
    12  	// Strings
    13  	if val1kind == reflect.String && val2kind == reflect.String {
    14  		return val1.(string) == val2.(string), nil
    15  	}
    16  
    17  	// Signed ints
    18  	if isSignedInt(val1kind) && isSignedInt(val2kind) {
    19  		var val1int64 int64
    20  		var val2int64 int64
    21  
    22  		switch val1kind {
    23  		case reflect.Int:
    24  			val1int64 = int64(val1.(int))
    25  		case reflect.Int8:
    26  			val1int64 = int64(val1.(int8))
    27  		case reflect.Int16:
    28  			val1int64 = int64(val1.(int16))
    29  		case reflect.Int32:
    30  			val1int64 = int64(val1.(int32))
    31  		case reflect.Int64:
    32  			val1int64 = int64(val1.(int64))
    33  		}
    34  
    35  		switch val2kind {
    36  		case reflect.Int:
    37  			val2int64 = int64(val2.(int))
    38  		case reflect.Int8:
    39  			val2int64 = int64(val2.(int8))
    40  		case reflect.Int16:
    41  			val2int64 = int64(val2.(int16))
    42  		case reflect.Int32:
    43  			val2int64 = int64(val2.(int32))
    44  		case reflect.Int64:
    45  			val2int64 = int64(val2.(int64))
    46  		}
    47  
    48  		return val1int64 == val2int64, nil
    49  	}
    50  
    51  	// Unsigned ints
    52  	if isUnsignedInt(val1kind) && isUnsignedInt(val2kind) {
    53  		var val1uint64 uint64
    54  		var val2uint64 uint64
    55  
    56  		switch val1kind {
    57  		case reflect.Uint:
    58  			val1uint64 = uint64(val1.(uint))
    59  		case reflect.Uint8:
    60  			val1uint64 = uint64(val1.(uint8))
    61  		case reflect.Uint16:
    62  			val1uint64 = uint64(val1.(uint16))
    63  		case reflect.Uint32:
    64  			val1uint64 = uint64(val1.(uint32))
    65  		case reflect.Uint64:
    66  			val1uint64 = uint64(val1.(uint64))
    67  		}
    68  
    69  		switch val2kind {
    70  		case reflect.Uint:
    71  			val2uint64 = uint64(val2.(uint))
    72  		case reflect.Uint8:
    73  			val2uint64 = uint64(val2.(uint8))
    74  		case reflect.Uint16:
    75  			val2uint64 = uint64(val2.(uint16))
    76  		case reflect.Uint32:
    77  			val2uint64 = uint64(val2.(uint32))
    78  		case reflect.Uint64:
    79  			val2uint64 = uint64(val2.(uint64))
    80  		}
    81  
    82  		return val1uint64 == val2uint64, nil
    83  	}
    84  
    85  	return false, errors.New("Invalid data types")
    86  }
    87  
    88  func isSignedInt(val reflect.Kind) bool {
    89  	signedIntTypes := []reflect.Kind{
    90  		reflect.Int,
    91  		reflect.Int8,
    92  		reflect.Int16,
    93  		reflect.Int32,
    94  		reflect.Int64,
    95  	}
    96  	for _, t := range signedIntTypes {
    97  		if val == t {
    98  			return true
    99  		}
   100  	}
   101  	return false
   102  }
   103  
   104  func isUnsignedInt(val reflect.Kind) bool {
   105  	unsignedIntTypes := []reflect.Kind{
   106  		reflect.Uint,
   107  		reflect.Uint8,
   108  		reflect.Uint16,
   109  		reflect.Uint32,
   110  		reflect.Uint64,
   111  	}
   112  	for _, t := range unsignedIntTypes {
   113  		if val == t {
   114  			return true
   115  		}
   116  	}
   117  	return false
   118  }
   119  
   120  func mapToRecords(mapRecordArray []map[string]interface{}) *records {
   121  	var recordArray records = make(records, 0)
   122  	for _, mapRecord := range mapRecordArray {
   123  		record := record{Data: mapRecord}
   124  		recordArray = append(recordArray, &record)
   125  	}
   126  	return &recordArray
   127  }