func (l ListOfUint8) fromElemSlice(p []uint8) []types.Value { r := make([]types.Value, len(p)) for i, v := range p { r[i] = types.Uint8(v) } return r }
func (def ListOfUint8Def) New() ListOfUint8 { l := make([]types.Value, len(def)) for i, d := range def { l[i] = types.Uint8(d) } return ListOfUint8{types.NewTypedList(__typeForListOfUint8, l...), &ref.Ref{}} }
func (s *testSuite) TestCSVImporterWithPipe() { oldDelimiter := delimiter newDelimiter := "|" delimiter = &newDelimiter defer func() { delimiter = oldDelimiter }() input, err := ioutil.TempFile(s.TempDir, "") d.Chk.NoError(err) defer input.Close() defer os.Remove(input.Name()) _, err = input.WriteString("a|b\n1|2\n") d.Chk.NoError(err) storeName := "store" setName := "csv" out := s.Run(main, []string{"-store", storeName, "-column-types", "String,Uint8", "-ds", setName, input.Name()}) s.Equal("", out) cs := chunks.NewLevelDBStore(s.LdbDir, storeName, 1, false) ds := dataset.NewDataset(datas.NewDataStore(cs), setName) defer ds.Store().Close() defer os.RemoveAll(s.LdbDir) l := ds.Head().Value().(types.List) s.Equal(uint64(1), l.Len()) v := l.Get(0) st := v.(types.Struct) s.Equal(types.NewString("1"), st.Get("a")) s.Equal(types.Uint8(2), st.Get("b")) }
func (def SetOfUint8Def) New() SetOfUint8 { l := make([]types.Value, len(def)) i := 0 for d, _ := range def { l[i] = types.Uint8(d) i++ } return SetOfUint8{types.NewTypedSet(__typeForSetOfUint8, l...), &ref.Ref{}} }
// StringToType takes a piece of data as a string and attempts to convert it to a types.Value of the appropriate types.NomsKind. func StringToType(s string, k types.NomsKind) types.Value { switch k { case types.Uint8Kind: ival, err := strconv.ParseUint(s, 10, 8) d.Chk.NoError(err) return types.Uint8(ival) case types.Uint16Kind: ival, err := strconv.ParseUint(s, 10, 16) d.Chk.NoError(err) return types.Uint16(ival) case types.Uint32Kind: ival, err := strconv.ParseUint(s, 10, 32) d.Chk.NoError(err) return types.Uint32(ival) case types.Uint64Kind: ival, err := strconv.ParseUint(s, 10, 64) d.Chk.NoError(err) return types.Uint64(ival) case types.Int8Kind: ival, err := strconv.ParseInt(s, 10, 8) d.Chk.NoError(err) return types.Int8(ival) case types.Int16Kind: ival, err := strconv.ParseInt(s, 10, 16) d.Chk.NoError(err) return types.Int16(ival) case types.Int32Kind: ival, err := strconv.ParseInt(s, 10, 32) d.Chk.NoError(err) return types.Int32(ival) case types.Int64Kind: ival, err := strconv.ParseInt(s, 10, 64) d.Chk.NoError(err) return types.Int64(ival) case types.Float32Kind: fval, err := strconv.ParseFloat(s, 32) d.Chk.NoError(err) return types.Float32(fval) case types.Float64Kind: fval, err := strconv.ParseFloat(s, 64) d.Chk.NoError(err) return types.Float64(fval) case types.BoolKind: bval, err := strconv.ParseBool(s) d.Chk.NoError(err) return types.Bool(bval) case types.StringKind: return types.NewString(s) default: d.Exp.Fail("Invalid column type kind:", k) } panic("not reached") }
func (s StructPrimitives) ChildValues() (ret []types.Value) { ret = append(ret, types.Uint64(s._uint64)) ret = append(ret, types.Uint32(s._uint32)) ret = append(ret, types.Uint16(s._uint16)) ret = append(ret, types.Uint8(s._uint8)) ret = append(ret, types.Int64(s._int64)) ret = append(ret, types.Int32(s._int32)) ret = append(ret, types.Int16(s._int16)) ret = append(ret, types.Int8(s._int8)) ret = append(ret, types.Float64(s._float64)) ret = append(ret, types.Float32(s._float32)) ret = append(ret, types.Bool(s._bool)) ret = append(ret, types.NewString(s._string)) ret = append(ret, s._blob) ret = append(ret, s._value) return }
func readerForStructPrimitives(v types.Value) []types.Value { values := []types.Value{} s := v.(StructPrimitives) values = append(values, types.Uint64(s._uint64)) values = append(values, types.Uint32(s._uint32)) values = append(values, types.Uint16(s._uint16)) values = append(values, types.Uint8(s._uint8)) values = append(values, types.Int64(s._int64)) values = append(values, types.Int32(s._int32)) values = append(values, types.Int16(s._int16)) values = append(values, types.Int8(s._int8)) values = append(values, types.Float64(s._float64)) values = append(values, types.Float32(s._float32)) values = append(values, types.Bool(s._bool)) values = append(values, types.NewString(s._string)) values = append(values, s._blob) values = append(values, s._value) return values }
func (s *testSuite) TestCSVImporter() { input, err := ioutil.TempFile(s.TempDir, "") d.Chk.NoError(err) defer input.Close() defer os.Remove(input.Name()) _, err = input.WriteString("a,b\n") d.Chk.NoError(err) for i := 0; i < 100; i++ { _, err = input.WriteString(fmt.Sprintf("a%d,%d\n", i, i)) d.Chk.NoError(err) } _, err = input.Seek(0, 0) d.Chk.NoError(err) storeName := "store" setName := "csv" out := s.Run(main, []string{"-store", storeName, "-column-types", "String,Uint8", "-ds", setName, input.Name()}) s.Equal("", out) cs := chunks.NewLevelDBStore(s.LdbDir, storeName, 1, false) ds := dataset.NewDataset(datas.NewDataStore(cs), setName) defer ds.Store().Close() defer os.RemoveAll(s.LdbDir) l := ds.Head().Value().(types.List) s.Equal(uint64(100), l.Len()) i := uint64(0) l.IterAll(func(v types.Value, j uint64) { s.Equal(i, j) st := v.(types.Struct) s.Equal(types.NewString(fmt.Sprintf("a%d", i)), st.Get("a")) s.Equal(types.Uint8(i), st.Get("b")) i++ }) }
func (l ListOfUint8) Set(i uint64, val uint8) ListOfUint8 { return ListOfUint8{l.l.Set(i, types.Uint8(val)), &ref.Ref{}} }
func (s SetOfUint8) Has(p uint8) bool { return s.s.Has(types.Uint8(p)) }