func (w *Huobi) checkAccount(a, price, amount string) bool {
btc, cny := w.get_account_info()
FPrice, err := strconv.ParseFloat(price, 64)
if err != nil {
logger.Debugln("price is not float")
return false
}
FAmount, err := strconv.ParseFloat(amount, 64)
if err != nil {
logger.Debugln("amount is not float")
return false
}
if a == "do_buy" {
if float64(cny) < FPrice*FAmount {
return false
}
} else {
if float64(btc) < FAmount {
return false
}
}
return true
}
func onRequest(w http.ResponseWriter, req *http.Request) {
req.ParseForm()
f := &Frame{xrange, yrange}
{
v, err := strconv.ParseFloat(req.FormValue("xr"), 64)
if err == nil {
f.xrange = v
}
v, err = strconv.ParseFloat(req.FormValue("yr"), 64)
if err == nil {
f.yrange = v
}
}
i := &Image{width, height}
{
v, err := strconv.Atoi(req.FormValue("w"))
if err == nil {
i.width = v
}
v, err = strconv.Atoi(req.FormValue("h"))
if err == nil {
i.height = v
}
}
run(w, f, i)
}
func doRow0(top *Top, line string) {
rexp := regexp.MustCompile(`top[\s\-0-9:]+up([:0-9A-z,\s]+?)([0-9] user.*)`)
matches := rexp.FindStringSubmatch(line)
if len(matches) != 3 {
return
}
top.Uptime = strings.Trim(matches[1], " ,")
ls := strings.Split(matches[2], ",")
if len(ls) != 4 {
return
}
// users
ls[0] = strings.TrimSpace(ls[0])
top.Users, _ = strconv.Atoi(strings.Split(ls[0], " ")[0])
// load avgs
// 5
if i := strings.Index(ls[1], "load average:"); i > -1 {
ls[1] = strings.TrimSpace(ls[1][i+13:])
top.LoadAvg5, _ = strconv.ParseFloat(ls[1], 64)
}
// 10
top.LoadAvg10, _ = strconv.ParseFloat(strings.TrimSpace(ls[2]), 64)
// 15
top.LoadAvg15, _ = strconv.ParseFloat(strings.TrimSpace(ls[3]), 64)
}
func (pfs *ProcFS) Get(k string) {
var uf = path.Join(procfsdir, "uptime")
switch k {
case PROCFS_SELF:
var selfdir = path.Join(procfsdir, "self")
if !exists(selfdir) {
return
}
fi, _ := os.Readlink(selfdir)
pfs.Self = fi
case PROCFS_UPTIME:
str, err := ioutil.ReadFile(uf)
if err == nil {
ss := strings.Fields(string(str))
if len(ss) >= 2 {
it, _ := strconv.ParseFloat(ss[0], 64)
pfs.Uptime = int(it)
}
}
case PROCFS_IDLETIME:
str, err := ioutil.ReadFile(uf)
if err == nil {
ss := strings.Fields(string(str))
if len(ss) >= 2 {
it, _ := strconv.ParseFloat(ss[1], 64)
pfs.Idletime = int(it)
}
}
case PROCFS_MOUNTS:
pfs.Mounts = getMounts(path.Join(procfsdir, "mounts"))
}
}
func transform(extractChannel, transformChannel chan *Order) {
f, _ := os.Open("./../productList.txt")
defer f.Close()
r := csv.NewReader(f)
records, _ := r.ReadAll()
productList := make(map[string]*Product)
for _, record := range records {
product := new(Product)
product.PartNumber = record[0]
product.UnitCost, _ = strconv.ParseFloat(record[1], 64)
product.UnitPrice, _ = strconv.ParseFloat(record[2], 64)
productList[product.PartNumber] = product
}
for o := range extractChannel {
time.Sleep(3 * time.Millisecond)
o.UnitCost = productList[o.PartNumber].UnitCost
o.UnitPrice = productList[o.PartNumber].UnitPrice
transformChannel <- o
}
close(transformChannel)
}
func CoerceFloat(v interface{}) (float64, error) {
switch val := v.(type) {
case int:
return float64(val), nil
case int32:
return float64(val), nil
case int64:
return float64(val), nil
case uint32:
return float64(val), nil
case uint64:
return float64(val), nil
case float64:
return val, nil
case string:
if len(val) > 0 {
if iv, err := strconv.ParseFloat(val, 64); err == nil {
return iv, nil
}
}
case []byte:
if len(val) > 0 {
if iv, err := strconv.ParseFloat(string(val), 64); err == nil {
return iv, nil
}
}
case json.RawMessage:
if len(val) > 0 {
if iv, err := strconv.ParseFloat(string(val), 64); err == nil {
return iv, nil
}
}
}
return 0, fmt.Errorf("Could not Coerce Value: %v", v)
}
func (qs *QuerySplitter) splitBoundariesFloatColumn(pkMinMax *sqltypes.Result) ([]sqltypes.Value, error) {
boundaries := []sqltypes.Value{}
if pkMinMax == nil || len(pkMinMax.Rows) != 1 || pkMinMax.Rows[0][0].IsNull() || pkMinMax.Rows[0][1].IsNull() {
return boundaries, nil
}
min, err := strconv.ParseFloat(pkMinMax.Rows[0][0].String(), 64)
if err != nil {
return nil, err
}
max, err := strconv.ParseFloat(pkMinMax.Rows[0][1].String(), 64)
if err != nil {
return nil, err
}
interval := (max - min) / float64(qs.splitCount)
if interval == 0 {
return nil, err
}
qs.rowCount = int64(interval)
for i := 1; i < int(qs.splitCount); i++ {
boundary := min + interval*float64(i)
v, err := sqltypes.BuildValue(boundary)
if err != nil {
return nil, err
}
boundaries = append(boundaries, v)
}
return boundaries, nil
}
func main() {
csvfile, err := os.Open("rosalind_ini2.txt")
if err != nil {
log.Fatal(err)
}
defer csvfile.Close()
reader := csv.NewReader(csvfile)
reader.Comma = ' '
reader.FieldsPerRecord = 2
records, err := reader.ReadAll()
if err != nil {
log.Fatal(err)
}
for _, record := range records {
a, err := strconv.ParseFloat(record[0], 64)
if err != nil {
log.Fatal(err)
}
b, err := strconv.ParseFloat(record[1], 64)
if err != nil {
log.Fatal(err)
}
result := (a * a) + (b * b)
fmt.Printf("%f\n", result)
return
}
}
// Get location (name, lat and lng)
// via NUS Web
func getLocationInfoNUS(query string) ([]LocationInfo, error) {
url := fmt.Sprintf("http://map.nus.edu.sg/index.php/search/by/%s", query)
doc, err := goquery.NewDocument(url)
if err != nil {
return nil, err
}
var locations []LocationInfo
s := doc.Find("#search_list a[href=\"javascript:void(0)\"]").First()
onclick, _ := s.Attr("onclick")
regex := regexp.MustCompile("long=([0-9\\.]+?)&lat=([0-9\\.]+?)'")
matches := regex.FindAllStringSubmatch(onclick, -1)
if len(matches) == 0 || len(matches[0]) != 3 {
return nil, fmt.Errorf("Can't find lat and lng from query: %s", query)
}
x, _ := strconv.ParseFloat(matches[0][1], 64)
y, _ := strconv.ParseFloat(matches[0][2], 64)
location := LocationInfo{
Name: s.Text(),
Lng: x,
Lat: y,
}
locations = append(locations, location)
return locations, nil
}
func SaveBehaviorLog(orgcode string, data []map[string]string) {
log.Println("SaveLog")
session := db.GetDBSession()
defer db.ReleaseDBSession(session)
c := session.DB("person_info").C("behavior_log")
bulk := c.Bulk()
for i, fields := range data {
log.Println(i, fields)
mac := fields["MAC"]
mac = filterMac(mac)
IpInt, err4 := strconv.ParseInt(fields["DST_IP"], 10, 64)
Ip := inet_ntoa(IpInt)
port := fields["DST_PORT"]
lng, err1 := strconv.ParseFloat(fields["LONGITUDE"], 64)
lat, err2 := strconv.ParseFloat(fields["LATITUDE"], 64)
if orgcode == "779852855" && err2 != nil {
lat, err2 = strconv.ParseFloat(fields["LAITTUDE"], 64)
}
time, err3 := strconv.Atoi(fields["CAPTURE_TIME"])
if err1 != nil || err2 != nil || err3 != nil || err4 != nil {
log.Println("error:", err1, err2, err3, err4)
continue
}
lng, lat = data_file.Bd09towgs84(lng, lat)
if saveToDB {
//c.Insert(fields)
bulk.Insert(bson.M{"mac": mac, "dst_ip": Ip, "dst_port": port, "longitude": lng, "latitude": lat, "org_code": orgcode, "time": uint32(time)})
}
}
bulk.Run()
}
// UnmarshalJSON implements json.Unmarshaller on AccountInfo.
// This is needed because the Vultr API is inconsistent in it's JSON responses for account info.
// Some fields can change type, from JSON number to JSON string and vice-versa.
func (a *AccountInfo) UnmarshalJSON(data []byte) (err error) {
if a == nil {
*a = AccountInfo{}
}
var fields map[string]interface{}
if err := json.Unmarshal(data, &fields); err != nil {
return err
}
b, err := strconv.ParseFloat(fmt.Sprintf("%v", fields["balance"]), 64)
if err != nil {
return err
}
a.Balance = b
pc, err := strconv.ParseFloat(fmt.Sprintf("%v", fields["pending_charges"]), 64)
if err != nil {
return err
}
a.PendingCharges = pc
lpa, err := strconv.ParseFloat(fmt.Sprintf("%v", fields["last_payment_amount"]), 64)
if err != nil {
return err
}
a.LastPaymentAmount = lpa
a.LastPaymentDate = fmt.Sprintf("%v", fields["last_payment_date"])
return
}
func SaveTraceInfo(orgcode string, data []map[string]string) {
log.Println("SaveTraceInfo")
session := db.GetDBSession()
defer db.ReleaseDBSession(session)
c := session.DB("detector").C("detector_report")
bulk := c.Bulk()
for i, fields := range data {
//log.Println(fields)
mac := fields["MAC"]
mac = filterMac(mac)
ap_mac := fields["ACCESS_AP_MAC"]
ap_mac = filterMac(ap_mac)
lng, err1 := strconv.ParseFloat(fields["COLLECTION_EQUIPMENT_LONGITUDE"], 64)
lat, err2 := strconv.ParseFloat(fields["COLLECTION_EQUIPMENT_LATITUDE"], 64)
time, err3 := strconv.Atoi(fields["CAPTURE_TIME"])
if err1 != nil || err2 != nil || err3 != nil {
continue
}
lng, lat = data_file.Bd09towgs84(lng, lat)
log.Println(i, ": mac", mac, "ap_mac", ap_mac, "lng", lng, "lat", lat, "time", time)
if saveToDB {
bulk.Insert(bson.M{"ap_mac": ap_mac, "device_mac": mac, "longitude": lng, "latitude": lat, "org_code": orgcode, "time": uint32(time)})
}
}
bulk.Run()
}
func (sm *statMonitor) Monitor(packets <-chan StatPacket, wg *sync.WaitGroup) {
var s StatPacket
var floatValue float64
var intValue int
t := time.Tick(time.Duration(sm.flushInterval) * time.Second)
ok := true
for ok {
select {
case <-t:
sm.Flush()
case s, ok = <-packets:
if !ok {
sm.Flush()
break
}
switch s.Modifier {
case "ms":
floatValue, _ = strconv.ParseFloat(s.Value, 64)
sm.timers[s.Bucket] = append(sm.timers[s.Bucket], floatValue)
case "g":
intValue, _ = strconv.Atoi(s.Value)
sm.gauges[s.Bucket] += intValue
default:
floatValue, _ = strconv.ParseFloat(s.Value, 32)
sm.counters[s.Bucket] += int(float32(floatValue) * (1 / s.Sampling))
}
}
}
log.Println("StatsdMonitor for input stopped: ", sm.ir.Name())
wg.Done()
}
func (s *StatsdInput) handleMessage(message []byte) {
var packet StatPacket
var value string
st := sanitizeRegexp.ReplaceAllString(string(message), "")
for _, item := range packetRegexp.FindAllStringSubmatch(st, -1) {
value = item[2]
if item[3] == "ms" {
_, err := strconv.ParseFloat(item[2], 32)
if err != nil {
value = "0"
}
}
sampleRate, err := strconv.ParseFloat(item[5], 32)
if err != nil {
sampleRate = 1
}
packet.Bucket = item[1]
packet.Value = value
packet.Modifier = item[3]
packet.Sampling = float32(sampleRate)
s.Packet <- packet
}
}
// convertFloat converts the string to a float64value.
func (s *ss) convertFloat(str string, n int) float64 {
if p := indexRune(str, 'p'); p >= 0 {
// Atof doesn't handle power-of-2 exponents,
// but they're easy to evaluate.
f, err := strconv.ParseFloat(str[:p], n)
if err != nil {
// Put full string into error.
if e, ok := err.(*strconv.NumError); ok {
e.Num = str
}
s.error(err)
}
m, err := strconv.Atoi(str[p+1:])
if err != nil {
// Put full string into error.
if e, ok := err.(*strconv.NumError); ok {
e.Num = str
}
s.error(err)
}
return math.Ldexp(f, m)
}
f, err := strconv.ParseFloat(str, n)
if err != nil {
s.error(err)
}
return f
}
func LoadAvg() (*LoadAvgStat, error) {
filename := common.HostProc("loadavg")
line, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
values := strings.Fields(string(line))
load1, err := strconv.ParseFloat(values[0], 64)
if err != nil {
return nil, err
}
load5, err := strconv.ParseFloat(values[1], 64)
if err != nil {
return nil, err
}
load15, err := strconv.ParseFloat(values[2], 64)
if err != nil {
return nil, err
}
ret := &LoadAvgStat{
Load1: load1,
Load5: load5,
Load15: load15,
}
return ret, nil
}
func HomeHandler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
vars := mux.Vars(r)
lat, latErr := strconv.ParseFloat(vars["lat"], 32)
if latErr != nil {
ReturnErrorToClient(w, latErr, "Invalid latitude value. Expecting a floating point number")
return
}
lng, lngErr := strconv.ParseFloat(vars["lng"], 32)
if lngErr != nil {
ReturnErrorToClient(w, lngErr, "Invalid longitude value. Expecting a floating point number")
return
}
tracelog.Trace("Lat Value", "main", "Lat is %f", lat)
tracelog.Trace("Lng Value", "main", "Lng is %f", lng)
postalCode, postaCodeErr := ReverseGeocodeToPostalCode(lat, lng)
if postaCodeErr != nil {
ReturnErrorToClient(w, postaCodeErr, "Error determining zip code from given coordinates")
return
}
tracelog.Trace("Postal Code Value", "main", "Postal Code is %s", postalCode)
var response = GeocodeResponse{postalCode}
w.WriteHeader(http.StatusOK)
var err error
if err = json.NewEncoder(w).Encode(response); err != nil {
tracelog.Error(err, "An error occurred while encoding json response", "NearbyHandler")
panic(err)
}
}
func (d *DataPoint) clean() error {
if err := d.Tags.Clean(); err != nil {
return fmt.Errorf("cleaning tags for metric %s: %s", d.Metric, err)
}
m, err := Clean(d.Metric)
if err != nil {
return fmt.Errorf("cleaning metric %s: %s", d.Metric, err)
}
if d.Metric != m {
d.Metric = m
}
switch v := d.Value.(type) {
case string:
if i, err := strconv.ParseInt(v, 10, 64); err == nil {
d.Value = i
} else if f, err := strconv.ParseFloat(v, 64); err == nil {
d.Value = f
} else {
return fmt.Errorf("Unparseable number %v", v)
}
case uint64:
if v > math.MaxInt64 {
d.Value = float64(v)
}
case *big.Int:
if bigMaxInt64.Cmp(v) < 0 {
if f, err := strconv.ParseFloat(v.String(), 64); err == nil {
d.Value = f
}
}
}
return nil
}
// parseLatLngs splits up a string of lat:lng points and returns the list of parsed
// entries.
func parseLatLngs(s string) []LatLng {
pieces := strings.Split(s, ",")
var lls []LatLng
for _, piece := range pieces {
// Skip empty strings.
if len(strings.TrimSpace(piece)) == 0 {
continue
}
p := strings.Split(strings.TrimSpace(piece), ":")
if len(p) != 2 {
panic(fmt.Sprintf("invalid input string for parseLatLngs: %q", piece))
}
lat, err := strconv.ParseFloat(p[0], 64)
if err != nil {
panic(fmt.Sprintf("invalid float in parseLatLngs: %q, err: %v", p[0], err))
}
lng, err := strconv.ParseFloat(p[1], 64)
if err != nil {
panic(fmt.Sprintf("invalid float in parseLatLngs: %q, err: %v", p[1], err))
}
lls = append(lls, LatLngFromDegrees(lat, lng))
}
return lls
}
// CgroupCPU returnes specified cgroup id CPU status.
// containerid is same as docker id if you use docker.
// If you use container via systemd.slice, you could use
// containerid = docker-<container id>.scope and base=/sys/fs/cgroup/cpuacct/system.slice/
func CgroupCPU(containerid string, base string) (*CPUTimesStat, error) {
if len(base) == 0 {
base = "/sys/fs/cgroup/cpuacct/docker"
}
path := path.Join(base, containerid, "cpuacct.stat")
lines, _ := readLines(path)
// empty containerid means all cgroup
if len(containerid) == 0 {
containerid = "all"
}
ret := &CPUTimesStat{CPU: containerid}
for _, line := range lines {
fields := strings.Split(line, " ")
if fields[0] == "user" {
user, err := strconv.ParseFloat(fields[1], 32)
if err == nil {
ret.User = float32(user)
}
}
if fields[0] == "system" {
system, err := strconv.ParseFloat(fields[1], 32)
if err == nil {
ret.System = float32(system)
}
}
}
return ret, nil
}
func ReadNormals(fileName string) []Vector {
file, err := os.Open(fileName)
common.Check(err)
defer file.Close()
scanner := bufio.NewScanner(file)
scanner.Split(bufio.ScanWords)
var normals []Vector
for scanner.Scan() {
x, err := strconv.ParseFloat(scanner.Text(), 64)
common.Check(err)
scanner.Scan()
y, err := strconv.ParseFloat(scanner.Text(), 64)
common.Check(err)
scanner.Scan()
z, err := strconv.ParseFloat(scanner.Text(), 64)
common.Check(err)
normals = append(normals, Vector{x, y, z})
}
common.Check(scanner.Err())
return normals
}
func loadData() []float32 {
csvfile, err := Asset("www/GDA94_SITE.CSV")
if err != nil {
fmt.Println(err)
return nil
}
file := bytes.NewReader(csvfile)
r := csv.NewReader(file)
records, err := r.ReadAll()
if err != nil {
log.Fatal(err)
}
var points []float32
for _, each := range records {
lat, _ := strconv.ParseFloat(each[1], 64)
lng, _ := strconv.ParseFloat(each[2], 64)
lng = 256 * (0.5 + lng/360)
lat = project(lat)
lat32, lng32 := float32(lat), float32(lng)
points = append(points, lng32)
points = append(points, lat32)
}
return points
}
// ParseFloat parse value and return Float object
func ParseFloat(arg interface{}) (Float, Error) {
switch obj := arg.(type) {
case string:
i, err := strconv.ParseFloat(obj, 64)
if err != nil {
return 0, ErrInvalid
}
return Float(i), nil
case bool:
if obj {
return Float(1.0), nil
}
return Float(0.0), nil
case int, int8, int32, int64, uint, uint8, uint32, uint64:
i, err := strconv.ParseFloat(fmt.Sprintf("%d", obj), 64)
if err != nil {
return 0, ErrInvalid
}
return Float(i), nil
case float32, float64, complex64:
i, err := strconv.ParseFloat(fmt.Sprintf("%f", obj), 64)
if err != nil {
return 0, ErrInvalid
}
return Float(i), nil
}
return 0, nil
}
func PollRequest(w http.ResponseWriter, req *http.Request) {
var result SiteResponse
var status SiteStatus
site, err := LookupSite(req.FormValue("conference"), req.Host, true)
if err != nil {
status = SiteStatus{Error: err}
} else if poll := req.FormValue("poll"); poll != "" {
status = SiteStatus{Status: poll}
if x, err := strconv.ParseFloat(req.FormValue("tracker_status_at"), 64); err == nil {
status.Seq = TrackerSeq(x)
}
var timeout time.Duration
if x, err := strconv.ParseFloat(req.FormValue("timeout"), 64); err == nil {
timeout = time.Duration(x * float64(time.Millisecond))
}
status = <-site.DifferentStatus(status, timeout)
} else {
status = <-site.Status()
}
if status.Error == nil {
result.Ok = true
result.Status = status.Status
result.Seq = status.Seq
} else {
result.Error = status.Error.Error()
}
outputResponse(w, result)
}
func setField(field reflect.Value, defaultVal string) {
var iface interface{}
var err error
switch field.Kind() {
case reflect.Bool:
iface, err = strconv.ParseBool(defaultVal)
case reflect.Int:
iface, err = strconv.ParseInt(defaultVal, 10, 64)
iface = int(iface.(int64))
case reflect.Int8:
iface, err = strconv.ParseInt(defaultVal, 10, 8)
iface = int8(iface.(int64))
case reflect.Int16:
iface, err = strconv.ParseInt(defaultVal, 10, 16)
iface = int16(iface.(int64))
case reflect.Int32:
iface, err = strconv.ParseInt(defaultVal, 10, 32)
iface = int32(iface.(int64))
case reflect.Int64:
t, err := time.ParseDuration(defaultVal)
if err == nil {
iface, err = t, nil
} else {
iface, err = strconv.ParseInt(defaultVal, 10, 64)
}
case reflect.Uint:
iface, err = strconv.ParseUint(defaultVal, 10, 64)
iface = uint(iface.(uint64))
case reflect.Uint8:
iface, err = strconv.ParseUint(defaultVal, 10, 8)
iface = uint8(iface.(uint64))
case reflect.Uint16:
iface, err = strconv.ParseUint(defaultVal, 10, 16)
iface = uint16(iface.(uint64))
case reflect.Uint32:
iface, err = strconv.ParseUint(defaultVal, 10, 32)
iface = uint32(iface.(uint64))
case reflect.Uint64:
iface, err = strconv.ParseUint(defaultVal, 10, 64)
case reflect.Uintptr:
iface, err = strconv.ParseUint(defaultVal, 10, 64)
iface = uintptr(iface.(uint64))
case reflect.Float32:
iface, err = strconv.ParseFloat(defaultVal, 32)
iface = float32(iface.(float64))
case reflect.Float64:
iface, err = strconv.ParseFloat(defaultVal, 64)
case reflect.String:
iface = defaultVal
default:
err = errInvalidFieldType
}
if err == nil {
if field.CanSet() {
field.Set(reflect.ValueOf(iface))
}
}
}
func (m VarnishPlugin) FetchMetrics() (map[string]float64, error) {
var out []byte
var err error
if m.VarnishName == "" {
out, err = exec.Command(m.VarnishStatPath, "-1").CombinedOutput()
} else {
out, err = exec.Command(m.VarnishStatPath, "-1", "-n", m.VarnishName).CombinedOutput()
}
if err != nil {
return nil, errors.New(fmt.Sprintf("%s: %s", err, out))
}
lineexp, err := regexp.Compile("^([^ ]+) +(\\d+)")
stat := make(map[string]float64)
for _, line := range strings.Split(string(out), "\n") {
match := lineexp.FindStringSubmatch(line)
if match == nil {
continue
}
switch match[1] {
case "client_req", "MAIN.client_req":
stat["requests"], err = strconv.ParseFloat(match[2], 64)
case "cache_hit", "MAIN.cache_hit":
stat["cache_hits"], err = strconv.ParseFloat(match[2], 64)
}
}
return stat, err
}
/*
* Function to format the reply of the PortFolio Stocks
* @params stocks: String which holds values like `GOOGL:0:$656.99,APPL:5:$96.11`
* @params stockdata: Stucture of the YAHOO API
* @return: Formatted string like 'GOOGL:0:+$656.99','APPL:5:+$96.11'
*/
func format_reply_portfoliostocks(stocks string, stockdata *StockData) string {
var value string
stock := strings.Split(stocks, ",")
for i := 0; i < len(stockdata.List.Resources); i++ {
StockName := stockdata.List.Resources[i].Resource.Fields.Symbol
for j := 0; j < len(stock); j++ {
if !strings.EqualFold(StockName, strings.Split(stock[j], ":")[0]) {
continue
}
CurrentMarketValue, _ := strconv.ParseFloat(stockdata.List.Resources[i].Resource.Fields.Price, 64)
StockPrice, _ := strconv.ParseFloat(strings.Split(stock[j], ":")[2], 64)
quantity := strings.Split(stock[j], ":")[1]
value = value + ",'" + StockName + ":" + quantity
if CurrentMarketValue > StockPrice {
value = value + ":+$"
} else if CurrentMarketValue < StockPrice {
value = value + ":-$"
} else {
value = value + ":$"
}
value = value + strconv.FormatFloat(CurrentMarketValue, 'f', 2, 64) + "'"
}
}
return strings.Trim(value, ",")
}
func handleMessage(conn *net.UDPConn, remaddr net.Addr, buf *bytes.Buffer) {
var packet Packet
var value string
var sanitizeRegexp = regexp.MustCompile("[^a-zA-Z0-9\\-_\\.:\\|@]")
var packetRegexp = regexp.MustCompile("([a-zA-Z0-9_]+):(\\-?[0-9\\.]+)\\|(c|ms)(\\|@([0-9\\.]+))?")
s := sanitizeRegexp.ReplaceAllString(buf.String(), "")
for _, item := range packetRegexp.FindAllStringSubmatch(s, -1) {
value = item[2]
if item[3] == "ms" {
_, err := strconv.ParseFloat(item[2], 32)
if err != nil {
value = "0"
}
}
sampleRate, err := strconv.ParseFloat(item[5], 32)
if err != nil {
sampleRate = 1
}
packet.Bucket = item[1]
packet.Value = value
packet.Modifier = item[3]
packet.Sampling = float32(sampleRate)
if *debug {
log.Println("Packet: bucket = %s, value = %s, modifier = %s, sampling = %f\n", packet.Bucket, packet.Value, packet.Modifier, packet.Sampling)
}
In <- packet
}
}
/*
ymin, ymax = 0 - not set
ymin = ymin and != 0 - single range value
ymin != ymax - fixed range
*/
func getYRange(w http.ResponseWriter, r *http.Request) (ymin, ymax float64, ok bool) {
var err error
yr := r.URL.Query().Get("yrange")
switch {
case yr == "":
ok = true
case strings.Contains(yr, `,`):
y := strings.Split(yr, `,`)
if len(y) != 2 {
web.BadRequest(w, r, "invalid yrange query param.")
return
}
ymin, err = strconv.ParseFloat(y[0], 64)
if err != nil {
web.BadRequest(w, r, "invalid yrange query param.")
return
}
ymax, err = strconv.ParseFloat(y[1], 64)
if err != nil {
web.BadRequest(w, r, "invalid yrange query param.")
return
}
default:
ymin, err = strconv.ParseFloat(yr, 64)
if err != nil || ymin <= 0 {
web.BadRequest(w, r, "invalid yrange query param.")
return
}
ymax = ymin
}
ok = true
return
}
func setGPOS(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
rr := new(GPOS)
rr.Hdr = h
l := <-c
if l.length == 0 {
return rr, nil, ""
}
_, e := strconv.ParseFloat(l.token, 64)
if e != nil || l.err {
return nil, &ParseError{f, "bad GPOS Longitude", l}, ""
}
rr.Longitude = l.token
<-c // zBlank
l = <-c
_, e = strconv.ParseFloat(l.token, 64)
if e != nil || l.err {
return nil, &ParseError{f, "bad GPOS Latitude", l}, ""
}
rr.Latitude = l.token
<-c // zBlank
l = <-c
_, e = strconv.ParseFloat(l.token, 64)
if e != nil || l.err {
return nil, &ParseError{f, "bad GPOS Altitude", l}, ""
}
rr.Altitude = l.token
return rr, nil, ""
}