gettc 1.6.2 → 1.7

data/dist/include/go/src/topcoder/reader.go

@@ -0,0 +1,266 @@
+package topcoder
+
+import (
+    "bytes"
+    "bufio"
+    "fmt"
+    "io"
+    "reflect"
+    "unicode"
+)
+
+func spaces(br *bufio.Reader) error {
+    for {
+        switch b, err := br.ReadByte(); {
+        case err == io.EOF:
+            return nil
+        case err != nil:
+            return err
+        case !unicode.IsSpace(rune(b)):
+            br.UnreadByte()
+            return nil
+        }
+    }
+    return nil
+}
+
+func genericExpect(br *bufio.Reader, what string, predicate func(byte) bool) error {
+    switch b, err := br.ReadByte(); {
+    case err == io.EOF:
+        return io.ErrUnexpectedEOF
+    case err != nil:
+        return err
+    case !predicate(b):
+        br.UnreadByte()
+        return NewErrExpect(br, what)
+    }
+    return nil
+}
+
+func expect(br *bufio.Reader, b byte) error {
+    return genericExpect(br, fmt.Sprintf("<%c>", b), func(got byte) bool {
+        return got == b
+    })
+}
+
+func next(br *bufio.Reader) error {
+    if err := spaces(br); err != nil {
+        return err
+    }
+    return expect(br, ',')
+}
+
+
+func readPrimitive(br *bufio.Reader, x interface{}) error {
+    _, err := fmt.Fscan(br, x)
+    return err
+}
+
+func readChar(br *bufio.Reader, pChar *byte) error {
+    var (
+        err error
+        b byte
+    )
+    if err = spaces(br); err != nil {
+        return err
+    }
+    if err = expect(br, '\''); err != nil {
+        return err
+    }
+    switch b, err = br.ReadByte(); {
+    case err == io.EOF:
+        return io.ErrUnexpectedEOF
+    case err != nil:
+        return err
+    }
+    if err = expect(br, '\''); err != nil {
+        return err
+    }
+    *pChar = b
+    return nil
+}
+
+
+func isEndOfString(br *bufio.Reader) (ended bool, text string, err error) {
+    var b byte
+    w := bytes.NewBufferString("")
+    for {
+        switch b, err = br.ReadByte(); {
+        case err == io.EOF:
+            ended = true
+            err = nil
+            return
+        case err != nil:
+            return
+        case b == ',' || b == ']':
+            br.UnreadByte()
+            ended = true
+            return
+        case !unicode.IsSpace(rune(b)):
+            ended = false
+            text = w.String()
+            err = nil
+            br.UnreadByte()
+            return
+        }
+        w.WriteByte(b)
+    }
+    return
+}
+
+func readString(br *bufio.Reader, pString *string) error {
+    var (
+        b byte
+        err error
+        ended bool
+        text string
+    )
+    if err = spaces(br); err != nil {
+        return err
+    }
+    if err = expect(br, '"'); err != nil {
+        return err
+    }
+    w := bytes.NewBufferString("")
+    for {
+        switch b, err = br.ReadByte(); {
+        case err == io.EOF:
+            return io.ErrUnexpectedEOF
+        case err != nil:
+            return err
+        case b != '"':
+            if err = w.WriteByte(b); err != nil {
+                return err
+            }
+            continue
+        }
+        switch ended, text, err = isEndOfString(br); {
+        case err != nil:
+            return err
+        case ended:
+            *pString = w.String()
+            return nil
+        }
+        w.WriteByte('"')
+        w.WriteString(text)
+    }
+    return nil
+}
+
+
+func isEndOfSlice(br *bufio.Reader) (bool, error) {
+    var (
+        b byte
+        err error
+    )
+    if err = spaces(br); err != nil {
+        return false, err
+    }
+    switch b, err = br.ReadByte(); {
+    case err != nil:
+        return false, err
+    case b == ']':
+        return true, nil
+    }
+    br.UnreadByte()
+    return false, nil
+}
+
+func betterNew(typ reflect.Type) reflect.Value {
+    ret := reflect.New(typ)
+    if typ.Kind() == reflect.Slice {
+        slice := reflect.MakeSlice(typ, 0, 0)
+        reflect.Indirect(ret).Set(slice)
+    }
+    return ret
+}
+
+func appendSlice(br *bufio.Reader, slice reflect.Value) error {
+    another := betterNew(slice.Type().Elem())
+    if err := readOne(br, another.Interface()); err != nil {
+        return err
+    }
+    slice.Set(reflect.Append(slice, another.Elem()))
+    return nil
+}
+
+func readSlice(br *bufio.Reader, x interface{}) error {
+    var (
+        err error
+        ended bool
+    )
+
+    value := reflect.ValueOf(x)
+    slice := value.Elem()
+    if slice.Kind() != reflect.Slice {
+        return NewErrType(value.Type())
+    }
+
+    if err = spaces(br); err != nil {
+        return err
+    }
+    if err = expect(br, '['); err != nil {
+        return err
+    }
+
+    switch ended, err = isEndOfSlice(br); {
+    case err != nil:
+        return err
+    case ended:
+        return nil
+    }
+    if err = appendSlice(br, slice); err != nil {
+        return err
+    }
+
+    for {
+        switch ended, err = isEndOfSlice(br); {
+        case err != nil:
+            return err
+        case ended:
+            return nil
+        }
+        if err = next(br); err != nil {
+            return err
+        }
+        if err = appendSlice(br, slice); err != nil {
+            return err
+        }
+    }
+
+	return nil
+}
+
+
+func readOne(br *bufio.Reader, x interface{}) error {
+    switch p := x.(type) {
+    case *bool, *int, *int64, *float32, *float64:
+        return readPrimitive(br, x)
+    case *byte:
+        return readChar(br, p)
+    case *string:
+        return readString(br, p)
+    default:
+        value := reflect.ValueOf(x)
+        if value.Kind() != reflect.Ptr {
+            return NewErrType(value.Type())
+        }
+        return readSlice(br, x)
+    }
+    return nil
+}
+
+func Read(r io.Reader, xs ...interface{}) error {
+    br := bufio.NewReader(r)
+    for i, x := range xs {
+        if i != 0 {
+            if err := next(br); err != nil {
+                return err
+            }
+        }
+        if err := readOne(br, x); err != nil {
+            return err
+        }
+    }
+    return nil
+}

data/dist/include/go/src/topcoder/reader_test.go

@@ -0,0 +1,335 @@
+package topcoder
+
+import (
+    "bufio"
+    "fmt"
+    "reflect"
+    "strings"
+    "testing"
+)
+
+func newReader(s string) *bufio.Reader {
+    return bufio.NewReader(strings.NewReader(s))
+}
+
+func unexpectedError(err error) string {
+    return " raised an unexpected Error: " + err.Error()
+}
+
+func expectError() string {
+    return " should have raised an error"
+}
+
+func mismatch(got, required interface{}) string {
+    return fmt.Sprintf(" got %v (expected %v instead)", got, required)
+}
+
+func TestReadBool(t *testing.T) {
+    type aTest struct {
+        in string
+        out bool
+        ok bool
+    }
+    var (
+        xs = []aTest {
+            aTest {"True", true, true},
+            aTest {"\n\t\n   fAlSe", false, true},
+            aTest {"truz", true, false},
+        }
+        got bool
+    )
+    for _, x := range xs {
+        br := newReader(x.in)
+        err := readOne(br, &got)
+        f := fmt.Sprintf("readOne(%q, *bool)", x.in)
+        switch {
+        case x.ok && err != nil:
+            t.Errorf(f + unexpectedError(err))
+        case !x.ok && err == nil:
+            t.Errorf(f + expectError())
+        case !x.ok && err != nil:
+            break
+        case got != x.out:
+            t.Errorf(f + mismatch(got, x.out))
+        }
+    }
+}
+
+func TestReadInt(t *testing.T) {
+    type aTest struct {
+        in string
+        out int
+        ok bool
+    }
+    var (
+        xs = []aTest {
+            aTest{"123", 123, true},
+            aTest{"\n\t\n   123", 123, true},
+            aTest{"x123", 123, false},
+        }
+        got int
+    )
+    for _, x := range xs {
+        br := newReader(x.in)
+        err := readOne(br, &got)
+        f := fmt.Sprintf("readOne(%q, *int)", x.in)
+        switch {
+        case x.ok && err != nil:
+            t.Errorf(f + unexpectedError(err))
+        case !x.ok && err == nil:
+            t.Errorf(f + expectError())
+        case !x.ok && err != nil:
+            break
+        case got != x.out:
+            t.Errorf(f + mismatch(got, x.out))
+        }
+    }
+}
+
+func TestReadInt64(t *testing.T) {
+    type aTest struct {
+        in string
+        out int64
+        ok bool
+    }
+    var (
+        xs = []aTest {
+            aTest{"1234567890123", 1234567890123, true},
+            aTest{"\n\t\n   1234567890123", 1234567890123, true},
+            aTest{"x123", 123, false},
+        }
+        got int64
+    )
+    for _, x := range xs {
+        br := newReader(x.in)
+        err := readOne(br, &got)
+        f := fmt.Sprintf("readOne(%q, *int64)", x.in)
+        switch {
+        case x.ok && err != nil:
+            t.Errorf(f + unexpectedError(err))
+        case !x.ok && err == nil:
+            t.Errorf(f + expectError())
+        case !x.ok && err != nil:
+            break
+        case got != x.out:
+            t.Errorf(f + mismatch(got, x.out))
+        }
+    }
+}
+
+func TestReadFloat64(t *testing.T) {
+    type aTest struct {
+        in string
+        out float64
+        ok bool
+    }
+    var (
+        xs = []aTest {
+            aTest{"12345.6789", 12345.6789, true},
+            aTest{"\n\t\n   12345.6789", 12345.6789, true},
+            aTest{"x123", 123.0, false},
+        }
+        got float64
+    )
+    for _, x := range xs {
+        br := newReader(x.in)
+        err := readOne(br, &got)
+        f := fmt.Sprintf("readOne(%q, *float64)", x.in)
+        switch {
+        case x.ok && err != nil:
+            t.Errorf(f + unexpectedError(err))
+        case !x.ok && err == nil:
+            t.Errorf(f + expectError())
+        case !x.ok && err != nil:
+            break
+        case got != x.out:
+            t.Errorf(f + mismatch(got, x.out))
+        }
+    }
+}
+
+func TestReadByte(t *testing.T) {
+    type aTest struct {
+        in string
+        out byte
+        ok bool
+    }
+    var (
+        xs = []aTest {
+            aTest{"'H'ello", 'H', true},
+            aTest{"\n\t 'H'23", 'H', true},
+            aTest{"Hello", 'H', false},
+        }
+        got byte
+    )
+    for _, x := range xs {
+        br := newReader(x.in)
+        err := readOne(br, &got)
+        f := fmt.Sprintf("readOne(%q, *byte)", x.in)
+        switch {
+        case x.ok && err != nil:
+            t.Errorf(f + unexpectedError(err))
+        case !x.ok && err == nil:
+            t.Errorf(f + expectError())
+        case !x.ok && err != nil:
+            break
+        case got != x.out:
+            t.Errorf(f + mismatch(got, x.out))
+        }
+    }
+}
+
+func TestReadString(t *testing.T) {
+    type aTest struct {
+        in string
+        out string
+        ok bool
+    }
+    var (
+        xs = []aTest {
+            aTest{"\"H e l l o\"", "H e l l o", true},
+            aTest{"\"Hello\"world", "Hello", false},
+            aTest{"\"Hello\"    , world", "Hello", true},
+            aTest{"\n\t \"Hello world\"!", "Hello world", false},
+            aTest{"Hello", "Hello", false},
+            aTest{"H\"ello\\\" worl\"d", "ello\" worl", false},
+            aTest{"H\"ello\\\" worl\"d", "ello\" worl", false},
+        }
+        got string
+    )
+    for _, x := range xs {
+        br := newReader(x.in)
+        err := readOne(br, &got)
+        f := fmt.Sprintf("readOne(%q, *string)", x.in)
+        switch {
+        case x.ok && err != nil:
+            t.Errorf(f + unexpectedError(err))
+        case !x.ok && err == nil:
+            t.Errorf(f + expectError())
+        case !x.ok && err != nil:
+            break
+        case got != x.out:
+            t.Errorf(f + mismatch(got, x.out))
+        }
+    }
+}
+
+func TestReadIntSlice(t *testing.T) {
+    type aTest struct {
+        in string
+        out []int
+        ok bool
+    }
+    var (
+        xs = []aTest {
+            aTest{"[]", []int {}, true},
+            aTest{"[1]", []int {1}, true},
+            aTest{"[1, 2, 3]", []int {1, 2, 3}, true},
+            aTest{"\n[\n1\t\n,2,3,1001\n\n]", []int {1, 2, 3, 1001}, true},
+            aTest{"\n[\n1\t\n,2,3,1001\n\n", []int {1, 2, 3, 1001}, false},
+        }
+    )
+    for _, x := range xs {
+        got := []int {}
+        br := newReader(x.in)
+        err := readOne(br, &got)
+        f := fmt.Sprintf("readOne(%q, *[]int)", x.in)
+        switch {
+        case x.ok && err != nil:
+            t.Errorf(f + unexpectedError(err))
+        case !x.ok && err == nil:
+            t.Errorf(f + expectError())
+        case !x.ok && err != nil:
+            break
+        case !reflect.DeepEqual(got, x.out):
+            t.Errorf(f + mismatch(got, x.out))
+        }
+    }
+}
+
+func TestReadStringSlice(t *testing.T) {
+    type aTest struct {
+        in string
+        out []string
+        ok bool
+    }
+    var (
+        xs = []aTest {
+            aTest{"[]", []string {}, true},
+            aTest{"[\"Hello\"]", []string {"Hello"}, true},
+            aTest{"[\"Hello\", \"World\"]", []string {"Hello", "World"}, true},
+            aTest{"[\"Hello \" World\"]", []string {"Hello \" World"}, true},
+            aTest{"\n[\n\"Hello\"\t\n,\n\"Wo\",\"rld\"\n\n]", []string {"Hello", "Wo", "rld"}, true},
+            aTest{"\n[\n\"Hello\"\t\n\n\n", []string {"Hello"}, false},
+        }
+    )
+    for _, x := range xs {
+        got := []string {}
+        br := newReader(x.in)
+        err := readOne(br, &got)
+        f := fmt.Sprintf("readOne(%q, *[]string)", x.in)
+        switch {
+        case x.ok && err != nil:
+            t.Errorf(f + unexpectedError(err))
+        case !x.ok && err == nil:
+            t.Errorf(f + expectError())
+        case !x.ok && err != nil:
+            break
+        case !reflect.DeepEqual(got, x.out):
+            t.Errorf(f + mismatch(got, x.out))
+        }
+    }
+}
+
+func TestReadSliceOfIntSlice(t *testing.T) {
+    type aTest struct {
+        in string
+        out [][]int
+        ok bool
+    }
+    var (
+        xs = []aTest {
+            aTest{"[[]]", [][]int {{}}, true},
+            aTest{"[[1],[2,3]]", [][]int {{1}, {2, 3}}, true},
+            aTest{"\n\t[\n[1,2],\n[]\n,[3, 4, 5]]", [][]int {{1, 2}, {}, {3, 4, 5}}, true},
+            aTest{"[[1], [2], [3]", [][]int {{}}, false},
+            aTest{"[[7, 8], []]", [][]int {{7, 8}, {}}, true},
+        }
+    )
+    for _, x := range xs {
+        var got [][]int
+        br := newReader(x.in)
+        err := readOne(br, &got)
+        f := fmt.Sprintf("readOne(%q, *[][]int)", x.in)
+        switch {
+        case x.ok && err != nil:
+            t.Errorf(f + unexpectedError(err))
+        case !x.ok && err == nil:
+            t.Errorf(f + expectError())
+        case !x.ok && err != nil:
+            break
+        case !reflect.DeepEqual(got, x.out):
+            t.Errorf(f + mismatch(got, x.out))
+        }
+    }
+}
+
+func TestReadAll(t *testing.T) {
+    var (
+        name string
+        age int
+        gender byte
+        average float32
+        courses []string
+        grades [][]float64
+    )
+    in := "\"Joe\", 20, 'M', 7.5, [\"Math\", \"Computer \"Science\"\"], [[7, 8], []]"
+    br := newReader(in)
+    f := fmt.Sprintf("Read(%v)", in)
+    Read(br, &name, &age, &gender, &average, &courses, &grades)
+    if name != "Joe" || age != 20 || average != 7.5 || gender != 'M' ||
+        !reflect.DeepEqual(courses, []string{"Math", "Computer \"Science\""}) ||
+        !reflect.DeepEqual(grades, [][]float64{{7, 8}, {}}) {
+        t.Errorf(f + " produces (%q, %d, &q, %f, %v, %v)", name, age, gender, average, courses, grades)
+    }
+}