github.com/Ali-iotechsys/sqlboiler/v4@v4.0.0-20221208124957-6aec9a5f1f71/types/pgeo/general.go (about)

     1  package pgeo
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"reflect"
     7  	"regexp"
     8  	"strconv"
     9  	"strings"
    10  )
    11  
    12  func iToS(src interface{}) (string, error) {
    13  	var val string
    14  	var err error
    15  
    16  	switch src.(type) {
    17  	case string:
    18  		val = src.(string)
    19  	case []byte:
    20  		val = string(src.([]byte))
    21  	default:
    22  		err = errors.New(fmt.Sprintf("incompatible type %v", reflect.ValueOf(src).Kind().String()))
    23  	}
    24  
    25  	return val, err
    26  }
    27  
    28  func parseNums(s []string) ([]float64, error) {
    29  	var pts = []float64{}
    30  	for _, p := range s {
    31  		pt, err := strconv.ParseFloat(p, 64)
    32  		if err != nil {
    33  			return pts, err
    34  		}
    35  
    36  		pts = append(pts, pt)
    37  	}
    38  
    39  	return pts, nil
    40  }
    41  
    42  func formatPoint(point Point) string {
    43  	return fmt.Sprintf(`(%v,%v)`, point.X, point.Y)
    44  }
    45  
    46  func formatPoints(points []Point) string {
    47  	var pts = []string{}
    48  	for _, p := range points {
    49  		pts = append(pts, formatPoint(p))
    50  	}
    51  	return strings.Join(pts, ",")
    52  }
    53  
    54  var parsePointRegexp = regexp.MustCompile(`^\((-?[0-9]+(?:\.[0-9]+)?),(-?[0-9]+(?:\.[0-9]+)?)\)$`)
    55  
    56  func parsePoint(pt string) (Point, error) {
    57  	var point = Point{}
    58  	var err error
    59  
    60  	pdzs := parsePointRegexp.FindStringSubmatch(pt)
    61  	if len(pdzs) != 3 {
    62  		return point, errors.New("wrong point")
    63  	}
    64  
    65  	nums, err := parseNums(pdzs[1:3])
    66  	if err != nil {
    67  		return point, err
    68  	}
    69  
    70  	point.X = nums[0]
    71  	point.Y = nums[1]
    72  
    73  	return point, nil
    74  }
    75  
    76  var parsePointsRegexp = regexp.MustCompile(`\((?:-?[0-9]+(?:\.[0-9]+)?),(?:-?[0-9]+(?:\.[0-9]+)?)\)`)
    77  
    78  func parsePoints(pts string) ([]Point, error) {
    79  	var points = []Point{}
    80  
    81  	pdzs := parsePointsRegexp.FindAllString(pts, -1)
    82  	for _, pt := range pdzs {
    83  		point, err := parsePoint(pt)
    84  		if err != nil {
    85  			return points, err
    86  		}
    87  
    88  		points = append(points, point)
    89  	}
    90  
    91  	return points, nil
    92  }
    93  
    94  func parsePointsSrc(src interface{}) ([]Point, error) {
    95  	val, err := iToS(src)
    96  	if err != nil {
    97  		return []Point{}, err
    98  	}
    99  
   100  	return parsePoints(val)
   101  }
   102  
   103  func newRandNum(nextInt func() int64) float64 {
   104  	return float64(nextInt())
   105  }