github.com/go-graphite/carbonapi@v0.17.0/pkg/parser/internal.go (about)

     1  package parser
     2  
     3  import (
     4  	"fmt"
     5  	"math"
     6  	"runtime/debug"
     7  	"strconv"
     8  	"strings"
     9  )
    10  
    11  func (e *expr) doGetIntArg() (int, error) {
    12  	if e.etype != EtConst {
    13  		if e.etype == EtString {
    14  			f, err := strconv.ParseInt(e.valStr, 0, 32)
    15  			return int(f), err
    16  		}
    17  		return 0, ErrBadType
    18  	}
    19  
    20  	return int(e.val), nil
    21  }
    22  
    23  func (e *expr) doGetIntOrInfArg() (IntOrInf, error) {
    24  	if e.etype == EtName && strings.ToLower(e.Target()) == "inf" ||
    25  		e.etype == EtString && strings.ToLower(e.valStr) == "inf" {
    26  		return IntOrInf{IsInf: true}, nil
    27  	}
    28  	intVal, err := e.doGetIntArg()
    29  	if err != nil {
    30  		return IntOrInf{}, err
    31  	}
    32  	return IntOrInf{IntVal: intVal}, nil
    33  }
    34  
    35  func (e *expr) getNamedArg(name string) *expr {
    36  	if a, ok := e.namedArgs[name]; ok {
    37  		return a
    38  	}
    39  
    40  	return nil
    41  }
    42  
    43  func (e *expr) doGetFloatArg() (float64, error) {
    44  	if e.etype != EtConst {
    45  		if e.etype == EtString {
    46  			f, err := strconv.ParseFloat(e.valStr, 64)
    47  			return f, err
    48  		} else if e.etype == EtName && strings.ToLower(e.Target()) == "inf" {
    49  			return math.Inf(1), nil
    50  		}
    51  		return 0, ErrBadType
    52  	}
    53  
    54  	return e.val, nil
    55  }
    56  
    57  func (e *expr) doGetStringArg() (string, error) {
    58  	if e.etype != EtString {
    59  		return "", ErrBadType
    60  	}
    61  
    62  	return e.valStr, nil
    63  }
    64  
    65  func (e *expr) doGetBoolArg() (bool, error) {
    66  	if e.etype != EtString && e.etype != EtBool && e.etype != EtConst {
    67  		return false, ErrBadType
    68  	}
    69  
    70  	switch e.valStr {
    71  	case "False", "false", "0":
    72  		return false, nil
    73  	case "True", "true", "1":
    74  		return true, nil
    75  	}
    76  
    77  	return false, ErrBadType
    78  }
    79  
    80  func (e *expr) toExpr() interface{} {
    81  	return e
    82  }
    83  
    84  func mergeNamedArgs(arg1, arg2 map[string]*expr) map[string]*expr {
    85  	res := make(map[string]*expr)
    86  
    87  	for k, v := range arg1 {
    88  		res[k] = v
    89  	}
    90  
    91  	for k, v := range arg2 {
    92  		res[k] = v
    93  	}
    94  
    95  	return res
    96  }
    97  
    98  func sliceExpr(args []interface{}) ([]*expr, map[string]*expr) {
    99  	var res []*expr
   100  	var nArgs map[string]*expr
   101  	for _, a := range args {
   102  		switch v := a.(type) {
   103  		case ArgName:
   104  			res = append(res, NewNameExpr(string(v)).toExpr().(*expr))
   105  		case ArgValue:
   106  			res = append(res, NewValueExpr(string(v)).toExpr().(*expr))
   107  		case float64:
   108  			res = append(res, NewConstExpr(v).toExpr().(*expr))
   109  		case int:
   110  			res = append(res, NewConstExpr(float64(v)).toExpr().(*expr))
   111  		case string:
   112  			res = append(res, NewTargetExpr(v).toExpr().(*expr))
   113  		case *expr:
   114  			res = append(res, v)
   115  		case Expr:
   116  			res = append(res, v.toExpr().(*expr))
   117  		case NamedArgs:
   118  			nArgsNew := mapExpr(v)
   119  			nArgs = mergeNamedArgs(nArgs, nArgsNew)
   120  		default:
   121  			panic(fmt.Sprintf("BUG! THIS SHOULD NEVER HAPPEN! Unknown type=%T\n%v\n", a, string(debug.Stack())))
   122  		}
   123  	}
   124  
   125  	return res, nArgs
   126  }
   127  
   128  func mapExpr(m NamedArgs) map[string]*expr {
   129  	if m == nil || len(m) == 0 {
   130  		return nil
   131  	}
   132  	res := make(map[string]*expr)
   133  	for k, a := range m {
   134  		switch v := a.(type) {
   135  		case ArgName:
   136  			res[k] = NewNameExpr(string(v)).toExpr().(*expr)
   137  		case ArgValue:
   138  			res[k] = NewValueExpr(string(v)).toExpr().(*expr)
   139  		case float64:
   140  			res[k] = NewConstExpr(v).toExpr().(*expr)
   141  		case int:
   142  			res[k] = NewConstExpr(float64(v)).toExpr().(*expr)
   143  		case string:
   144  			res[k] = NewTargetExpr(v).toExpr().(*expr)
   145  		case Expr:
   146  			res[k] = v.toExpr().(*expr)
   147  		default:
   148  			return nil
   149  		}
   150  	}
   151  
   152  	return res
   153  }