github.com/suntong/easygen@v5.3.0+incompatible/egCal/consul-template_functions.go (about)

     1  ////////////////////////////////////////////////////////////////////////////
     2  // Package: egCal
     3  // Purpose: easygen generic calculation functionalities
     4  // Authors: @HashiCorp (c) 2013-17, All rights reserved
     5  //          https://github.com/hashicorp/consul-template/blob/de2ebf4/template_functions.go#L727-L901
     6  ////////////////////////////////////////////////////////////////////////////
     7  
     8  package egCal
     9  
    10  import (
    11  	"fmt"
    12  	"reflect"
    13  )
    14  
    15  // Add returns the sum of a and b.
    16  func Add(a, b interface{}) (interface{}, error) {
    17  	av := reflect.ValueOf(a)
    18  	bv := reflect.ValueOf(b)
    19  
    20  	switch av.Kind() {
    21  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
    22  		switch bv.Kind() {
    23  		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
    24  			return av.Int() + bv.Int(), nil
    25  		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
    26  			return av.Int() + int64(bv.Uint()), nil
    27  		case reflect.Float32, reflect.Float64:
    28  			return float64(av.Int()) + bv.Float(), nil
    29  		default:
    30  			return nil, fmt.Errorf("add: unknown type for %q (%T)", bv, b)
    31  		}
    32  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
    33  		switch bv.Kind() {
    34  		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
    35  			return int64(av.Uint()) + bv.Int(), nil
    36  		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
    37  			return av.Uint() + bv.Uint(), nil
    38  		case reflect.Float32, reflect.Float64:
    39  			return float64(av.Uint()) + bv.Float(), nil
    40  		default:
    41  			return nil, fmt.Errorf("add: unknown type for %q (%T)", bv, b)
    42  		}
    43  	case reflect.Float32, reflect.Float64:
    44  		switch bv.Kind() {
    45  		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
    46  			return av.Float() + float64(bv.Int()), nil
    47  		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
    48  			return av.Float() + float64(bv.Uint()), nil
    49  		case reflect.Float32, reflect.Float64:
    50  			return av.Float() + bv.Float(), nil
    51  		default:
    52  			return nil, fmt.Errorf("add: unknown type for %q (%T)", bv, b)
    53  		}
    54  	default:
    55  		return nil, fmt.Errorf("add: unknown type for %q (%T)", av, a)
    56  	}
    57  }
    58  
    59  // Subtract returns the difference of b from a.
    60  func Subtract(a, b interface{}) (interface{}, error) {
    61  	av := reflect.ValueOf(a)
    62  	bv := reflect.ValueOf(b)
    63  
    64  	switch av.Kind() {
    65  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
    66  		switch bv.Kind() {
    67  		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
    68  			return av.Int() - bv.Int(), nil
    69  		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
    70  			return av.Int() - int64(bv.Uint()), nil
    71  		case reflect.Float32, reflect.Float64:
    72  			return float64(av.Int()) - bv.Float(), nil
    73  		default:
    74  			return nil, fmt.Errorf("subtract: unknown type for %q (%T)", bv, b)
    75  		}
    76  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
    77  		switch bv.Kind() {
    78  		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
    79  			return int64(av.Uint()) - bv.Int(), nil
    80  		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
    81  			return av.Uint() - bv.Uint(), nil
    82  		case reflect.Float32, reflect.Float64:
    83  			return float64(av.Uint()) - bv.Float(), nil
    84  		default:
    85  			return nil, fmt.Errorf("subtract: unknown type for %q (%T)", bv, b)
    86  		}
    87  	case reflect.Float32, reflect.Float64:
    88  		switch bv.Kind() {
    89  		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
    90  			return av.Float() - float64(bv.Int()), nil
    91  		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
    92  			return av.Float() - float64(bv.Uint()), nil
    93  		case reflect.Float32, reflect.Float64:
    94  			return av.Float() - bv.Float(), nil
    95  		default:
    96  			return nil, fmt.Errorf("subtract: unknown type for %q (%T)", bv, b)
    97  		}
    98  	default:
    99  		return nil, fmt.Errorf("subtract: unknown type for %q (%T)", av, a)
   100  	}
   101  }
   102  
   103  // Multiply returns the product of a and b.
   104  func Multiply(a, b interface{}) (interface{}, error) {
   105  	av := reflect.ValueOf(a)
   106  	bv := reflect.ValueOf(b)
   107  
   108  	switch av.Kind() {
   109  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   110  		switch bv.Kind() {
   111  		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   112  			return av.Int() * bv.Int(), nil
   113  		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
   114  			return av.Int() * int64(bv.Uint()), nil
   115  		case reflect.Float32, reflect.Float64:
   116  			return float64(av.Int()) * bv.Float(), nil
   117  		default:
   118  			return nil, fmt.Errorf("multiply: unknown type for %q (%T)", bv, b)
   119  		}
   120  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
   121  		switch bv.Kind() {
   122  		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   123  			return int64(av.Uint()) * bv.Int(), nil
   124  		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
   125  			return av.Uint() * bv.Uint(), nil
   126  		case reflect.Float32, reflect.Float64:
   127  			return float64(av.Uint()) * bv.Float(), nil
   128  		default:
   129  			return nil, fmt.Errorf("multiply: unknown type for %q (%T)", bv, b)
   130  		}
   131  	case reflect.Float32, reflect.Float64:
   132  		switch bv.Kind() {
   133  		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   134  			return av.Float() * float64(bv.Int()), nil
   135  		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
   136  			return av.Float() * float64(bv.Uint()), nil
   137  		case reflect.Float32, reflect.Float64:
   138  			return av.Float() * bv.Float(), nil
   139  		default:
   140  			return nil, fmt.Errorf("multiply: unknown type for %q (%T)", bv, b)
   141  		}
   142  	default:
   143  		return nil, fmt.Errorf("multiply: unknown type for %q (%T)", av, a)
   144  	}
   145  }
   146  
   147  // Divide returns the division of b from a.
   148  func Divide(a, b interface{}) (interface{}, error) {
   149  	av := reflect.ValueOf(a)
   150  	bv := reflect.ValueOf(b)
   151  
   152  	switch av.Kind() {
   153  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   154  		switch bv.Kind() {
   155  		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   156  			return av.Int() / bv.Int(), nil
   157  		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
   158  			return av.Int() / int64(bv.Uint()), nil
   159  		case reflect.Float32, reflect.Float64:
   160  			return float64(av.Int()) / bv.Float(), nil
   161  		default:
   162  			return nil, fmt.Errorf("divide: unknown type for %q (%T)", bv, b)
   163  		}
   164  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
   165  		switch bv.Kind() {
   166  		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   167  			return int64(av.Uint()) / bv.Int(), nil
   168  		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
   169  			return av.Uint() / bv.Uint(), nil
   170  		case reflect.Float32, reflect.Float64:
   171  			return float64(av.Uint()) / bv.Float(), nil
   172  		default:
   173  			return nil, fmt.Errorf("divide: unknown type for %q (%T)", bv, b)
   174  		}
   175  	case reflect.Float32, reflect.Float64:
   176  		switch bv.Kind() {
   177  		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   178  			return av.Float() / float64(bv.Int()), nil
   179  		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
   180  			return av.Float() / float64(bv.Uint()), nil
   181  		case reflect.Float32, reflect.Float64:
   182  			return av.Float() / bv.Float(), nil
   183  		default:
   184  			return nil, fmt.Errorf("divide: unknown type for %q (%T)", bv, b)
   185  		}
   186  	default:
   187  		return nil, fmt.Errorf("divide: unknown type for %q (%T)", av, a)
   188  	}
   189  }