package main
import "fmt"
import "reflect"
import "strconv"
import "strings"
type scanner struct {
len int
parts []int
}
func (ss *scanner) Scan(s string, args ...interface{}) (n int, err error) {
if i := len(s); i != ss.len {
return 0, fmt.Errorf("exepected string of size %d, actual %d", ss.len, i)
}
if len(args) != len(ss.parts) {
return 0, fmt.Errorf("expected %d args, actual %d", len(ss.parts), len(args))
}
n = 0
start := 0
for ; n < len(args); n++ {
a := args[n]
l := ss.parts[n]
if err = scanOne(s[start:start+l], a); err != nil {
return
}
start += l
}
return n, nil
}
func newScan(parts ...int) *scanner {
len := 0
for _, v := range parts {
len += v
}
return &scanner{len, parts}
}
func scanOne(s string, arg interface{}) (err error) {
s = strings.TrimSpace(s)
switch v := arg.(type) {
case *int:
if s == "" {
*v = int(0)
} else {
*v, err = strconv.Atoi(s)
}
case *int32:
if s == "" {
*v = int32(0)
} else {
var val int64
val, err = strconv.ParseInt(s, 10, 32)
*v = int32(val)
}
case *int64:
if s == "" {
*v = int64(0)
} else {
*v, err = strconv.ParseInt(s, 10, 64)
}
case *float32:
if s == "" {
*v = float32(0)
} else {
var val float64
val, err = strconv.ParseFloat(s, 32)
*v = float32(val)
}
case *float64:
if s == "" {
*v = float64(0)
} else {
*v, err = strconv.ParseFloat(s, 64)
}
default:
val := reflect.ValueOf(v)
err = fmt.Errorf("can't scan type: " + val.Type().String())
}
return
}
func main() {
s := newScan(2, 4, 2)
var a int
var b float32
var c int32
s.Scan("12 2.2 1", &a, &b, &c)
fmt.Printf("%d %f %d
", a, b, c)
s.Scan("1 2", &a, &b, &c)
fmt.Printf("%d %f %d
", a, b, c)
s.Scan(" ", &a, &b, &c)
fmt.Printf("%d %f %d
", a, b, c)
}
Output:
12 2.200000 1
1 0.000000 1
0 0.000000 0
Notice that Scan function returns n - number of parsed arguments and err. If value is missing the function will set it to 0. The implementation is mostly taken from fmt.Scanf.