Пример #1
0
// Read a single sequence and return it or an error.
// TODO: Does not read multi-line fastq.
func (self *Reader) Read() (s seq.Sequence, err error) {
	var (
		buff, line, label []byte
		isPrefix          bool
		seqBuff           []alphabet.QLetter
		t                 seqio.SequenceAppender
	)

	inQual := false

	for {
		if buff, isPrefix, err = self.r.ReadLine(); err == nil {
			if isPrefix {
				line = append(line, buff...)
				continue
			} else {
				line = buff
			}

			line = bytes.TrimSpace(line)
			if len(line) == 0 {
				continue
			}
			switch {
			case !inQual && line[0] == '@':
				t = self.readHeader(line)
				label, line = line, nil
			case !inQual && line[0] == '+':
				if len(label) == 0 {
					return nil, bio.NewError("fastq: no header line parsed before +line in fastq format", 0)
				}
				if len(line) > 1 && bytes.Compare(label[1:], line[1:]) != 0 {
					return nil, bio.NewError("fastq: quality header does not match sequence header", 0)
				}
				inQual = true
			case !inQual:
				line = bytes.Join(bytes.Fields(line), nil)
				seqBuff = make([]alphabet.QLetter, len(line))
				for i := range line {
					seqBuff[i].L = alphabet.Letter(line[i])
				}
			case inQual:
				line = bytes.Join(bytes.Fields(line), nil)
				if len(line) != len(seqBuff) {
					return nil, bio.NewError("fastq: sequence/quality length mismatch", 0)
				}
				for i := range line {
					seqBuff[i].Q = alphabet.DecodeToQphred(line[i], self.enc)
				}
				t.AppendQLetters(seqBuff...)

				return t, nil
			}
		} else {
			return
		}
	}

	panic("cannot reach")
}
Пример #2
0
func ram() string {
	f, err := os.Open("/proc/meminfo")
	if err != nil {
		return fmt.Sprint(err)
	}
	defer f.Close()

	bufReader := bufio.NewReader(f)
	b := make([]byte, 100)
	var free, total string
	for line, isPrefix, err := bufReader.ReadLine(); err != io.EOF; line, isPrefix, err = bufReader.ReadLine() {
		b = append(b, line...)

		if !isPrefix {
			switch {
			case bytes.Contains(b, []byte("MemFree")):
				s := bytes.Fields(b)
				free = string(s[1])
			case bytes.Contains(b, []byte("MemTotal")):
				s := bytes.Fields(b)
				total = string(s[1])
			}
			b = b[:0]
		}
	}
	return fmt.Sprintf("%s/%s", free, total)
}
Пример #3
0
func ram() interface{} {
	f, err := os.Open("/proc/meminfo")
	if err != nil {
		return "Unsupported"
	}
	defer f.Close()

	bufReader := bufio.NewReader(f)
	b := make([]byte, 0, 100)
	var free, total int

	for line, isPrefix, err := bufReader.ReadLine(); err != io.EOF; line, isPrefix, err = bufReader.ReadLine() {
		if err != nil {
			log.Fatal("bufReader.ReadLine: ", err)
		}
		b = append(b, line...)

		if !isPrefix {
			switch {
			case bytes.Contains(b, []byte("MemFree")):
				free = toInt(bytes.Fields(b)[1])
			case bytes.Contains(b, []byte("MemTotal")):
				total = toInt(bytes.Fields(b)[1])
			}
			b = b[:0]
		}
	}
	return Ram{free, total}
}
Пример #4
0
func readDataSetFile(filename string) (d *DataSet) {
	d = new(DataSet)
	data, err := ioutil.ReadFile(filename)
	if err != nil {
		fmt.Println("Error opening file: ", filename)
		return
	}
	lines := bytes.Split(data, []byte{'\n'})
	names := bytes.Fields(lines[0])
	for i := 0; i < len(names)-1; i++ {
		d.var_names = append(d.var_names, string(names[i]))
	}
	d.out_name = string(names[len(names)-1])

	for i := 1; i < len(lines); i++ {
		val_strs := bytes.Fields(lines[i])
		if len(val_strs) < len(d.var_names)+1 {
			break
		}
		input := make([]float64, len(d.var_names))

		for p := 0; p < len(d.var_names); p++ {
			var val float64
			fmt.Sscanf(string(val_strs[p]), "%f", &val)
			input[p] = val
		}
		d.input = append(d.input, input)
		var out float64
		fmt.Sscanf(string(val_strs[len(val_strs)-1]), "%f", &out)
		d.output = append(d.output, out)
	}

	return
}
Пример #5
0
func New(r io.Reader) (*Grammar, error) {
	buf := bufio.NewReader(r)
	g := &Grammar{data: make(map[string][][]string)}
	start, err := buf.Peek(80)
	if err != nil {
		return nil, err
	}
	g.start = string(bytes.Fields(start)[0])
	line, err := buf.ReadSlice('.')
	for ; err == nil; line, err = buf.ReadSlice('.') {
		splat := bytes.Fields(line) // First field is left side, last is ".".
		stringified := make([]string, len(splat)-2)
		for i, word := range splat[1 : len(splat)-1] {
			stringified[i] = string(word)
		}
		key := string(splat[0])
		g.data[key] = append(g.data[key], stringified)
	}
	if err != io.EOF {
		return g, err
	}
	for _, c := range line { // leftovers
		if !unicode.IsSpace(rune(c)) { // i.e. there's something after the last '.':
			return g, io.ErrUnexpectedEOF
		}
	}
	return g, nil
}
Пример #6
0
func parseCommit(r io.Reader, resultSize string, name SHA) (Commit, error) {
	var commit = Commit{_type: "commit", size: resultSize}

	scnr := bufio.NewScanner(r)
	scnr.Split(ScanLinesNoTrim)

	var commitMessageLines [][]byte
	for scnr.Scan() {
		line := scnr.Bytes()
		trimmedLine := bytes.TrimRight(line, "\r\n")
		if commitMessageLines == nil && len(bytes.Fields(trimmedLine)) == 0 {
			// Everything after the first empty line is the commit message
			commitMessageLines = [][]byte{}
			continue
		}

		if commitMessageLines != nil {
			// We have already seen an empty line
			commitMessageLines = append(commitMessageLines, line)
			continue
		}

		parts := bytes.Fields(trimmedLine)
		key := parts[0]
		switch keyType(key) {
		case treeKey:
			commit.Tree = string(parts[1])
		case parentKey:
			commit.Parents = append(commit.Parents, SHA(string(parts[1])))
		case authorKey:
			authorline := string(bytes.Join(parts[1:], []byte(" ")))
			author, date, err := parseAuthorString(authorline)
			if err != nil {
				return commit, err
			}
			commit.Author = author
			commit.AuthorDate = date
		case committerKey:
			committerline := string(bytes.Join(parts[1:], []byte(" ")))
			committer, date, err := parseCommitterString(committerline)
			if err != nil {
				return commit, err
			}
			commit.Committer = committer
			commit.CommitterDate = date
		default:
			err := fmt.Errorf("encountered unknown field in commit: %s", key)
			return commit, err
		}
	}
	commit.Name = name
	commit.Message = bytes.Join(commitMessageLines, []byte("\n"))
	return commit, nil
}
Пример #7
0
// Read a single sequence and return it or an error.
// TODO: Does not read interleaved fastq.
func (self *Reader) Read() (sequence *seq.Seq, err error) {
	if self.r == nil {
		self.r = bufio.NewReader(self.f)
	}
	var line, label, seqBody, qualBody []byte
	sequence = &seq.Seq{}

	inQual := false
READ:
	for {
		if line, err = self.r.ReadBytes('\n'); err == nil {
			if len(line) > 0 && line[len(line)-1] == '\r' {
				line = line[:len(line)-1]
			}
			line = bytes.TrimSpace(line)
			if len(line) == 0 {
				continue
			}
			switch {
			case !inQual && line[0] == '@':
				label = line[1:]
			case !inQual && line[0] == '+':
				if len(label) == 0 {
					return nil, errors.New("No ID line parsed at +line in fastq format")
				}
				if len(line) > 1 && bytes.Compare(label, line[1:]) != 0 {
					return nil, errors.New("Quality ID does not match sequence ID")
				}
				inQual = true
			case !inQual:
				line = bytes.Join(bytes.Fields(line), nil)
				seqBody = append(seqBody, line...)
			case inQual:
				line = bytes.Join(bytes.Fields(line), nil)
				qualBody = append(qualBody, line...)
				if len(qualBody) >= len(seqBody) {
					break READ
				}
			}
		} else {
			return
		}
	}

	if len(seqBody) != len(qualBody) {
		return nil, errors.New("Quality length does not match sequence length")
	}
	sequence = seq.New(label, seqBody, qualBody)

	return
}
Пример #8
0
func discoverGatewayUsingRoute() (ip net.IP, err error) {
	routeCmd := exec.Command("route", "-n")
	stdOut, err := routeCmd.StdoutPipe()
	if err != nil {
		return
	}
	if err = routeCmd.Start(); err != nil {
		return
	}
	output, err := ioutil.ReadAll(stdOut)
	if err != nil {
		return
	}

	// Linux route out format is always like this:
	// Kernel IP routing table
	// Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
	// 0.0.0.0         192.168.1.1     0.0.0.0         UG    0      0        0 eth0
	outputLines := bytes.Split(output, []byte("\n"))
	for _, line := range outputLines {
		if bytes.Contains(line, []byte("0.0.0.0")) {
			ipFields := bytes.Fields(line)
			ip = net.ParseIP(string(ipFields[1]))
			break
		}
	}
	err = routeCmd.Wait()
	return
}
Пример #9
0
func discoverGatewayUsingIp() (ip net.IP, err error) {
	routeCmd := exec.Command("ip", "route", "show")
	stdOut, err := routeCmd.StdoutPipe()
	if err != nil {
		return
	}
	if err = routeCmd.Start(); err != nil {
		return
	}
	output, err := ioutil.ReadAll(stdOut)
	if err != nil {
		return
	}

	// Linux 'ip route show' format looks like this:
	// default via 192.168.178.1 dev wlp3s0  metric 303
	// 192.168.178.0/24 dev wlp3s0  proto kernel  scope link  src 192.168.178.76  metric 303
	outputLines := bytes.Split(output, []byte("\n"))
	for _, line := range outputLines {
		if bytes.Contains(line, []byte("default")) {
			ipFields := bytes.Fields(line)
			ip = net.ParseIP(string(ipFields[2]))
			break
		}
	}
	err = routeCmd.Wait()
	return
}
Пример #10
0
// loadGoodTable can be used to parse string heap that
// headers and values are arranged in right order
func loadGoodTable(table []byte, dumpZeros bool) (map[string]interface{}, error) {
	entries := map[string]interface{}{}
	fields := bytes.Fields(table)
	var value int64
	var err error
	// iterate over two values each time
	// first value is header, second is value
	for i := 0; i < len(fields); i = i + 2 {
		// counter is zero
		if bytes.Equal(fields[i+1], zeroByte) {
			if !dumpZeros {
				continue
			} else {
				entries[string(fields[i])] = int64(0)
				continue
			}
		}
		// the counter is not zero, so parse it.
		value, err = strconv.ParseInt(string(fields[i+1]), 10, 64)
		if err == nil {
			entries[string(fields[i])] = value
		}
	}
	return entries, nil
}
Пример #11
0
// ValidatePacket validates a carbon message.
func ValidatePacket(buf []byte) error {
	fields := bytes.Fields(buf)
	if len(fields) != 3 {
		return errors.New("packet must consist of 3 fields")

	}

	version := GetVersionB(fields[0])
	err := InitialValidationB(fields[0], version)
	if err != nil {
		return err
	}

	_, err = strconv.ParseFloat(string(fields[1]), 32)
	if err != nil {
		return errors.New("value field is not a float or int")
	}

	_, err = strconv.ParseUint(string(fields[2]), 10, 0)
	if err != nil {
		return errors.New("timestamp field is not a unix timestamp")
	}

	return nil
}
Пример #12
0
func (s *Statements) Scan() {
	go s.Parser.Parse()

	scanner := bufio.NewScanner(s.Parser)

	depth := 0
	scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
		if i := bytes.IndexAny(data, ";{}"); i >= 0 {
			if string(data[i]) == "{" {
				depth++
			} else if string(data[i]) == "}" {
				depth--
			}
			return i + 1, data[0:i], nil
		} else if atEOF {
			return len(data), nil, nil
		}
		return 0, nil, nil
	})

	for scanner.Scan() {
		stmt := string(bytes.Join(bytes.Fields(scanner.Bytes()), []byte{' '}))
		s.stmts <- &stmtMsg{stmt, depth}
	}
}
Пример #13
0
func (f Format) TheHour(n int, t time.Time) (b []byte) {
	b = make([]byte, 0, 64)
	for _, f := range bytes.Fields(f) {
		switch f[0] {
		case '#':
			b = append(b, Numbers[n]...)
		case 'h':
			b = append(b, []byte(`THE HOUR`)...)
		case 'm':
			m := t.Minute()
			b = append(b, Numbers[m]...)
			if len(f) == 2 && f[1] == '_' {
				b = append(b, Sminute...)
				if m != 1 {
					b = append(b, 'S')
				}
			}
		case 's':
			s := t.Second()
			b = append(b, Numbers[s]...)
			if len(f) == 2 && f[1] == '_' {
				b = append(b, Ssecond...)
				if s != 1 {
					b = append(b, 'S')
				}
			}
		default:
			b = append(b, f...)
		}
		b = append(b, ' ')
	}
	return b[:len(b)-1]
}
Пример #14
0
func TestCache(t *testing.T) {

	// Test data was generated from the python code
	f, err := os.Open("testdata/domains.txt")

	if err != nil {
		t.Fatal(err)
	}

	scanner := bufio.NewScanner(f)

	cache := New(200)

	for scanner.Scan() {
		fields := bytes.Fields(scanner.Bytes())

		key := string(fields[0])
		wantHit := fields[1][0] == 'h'

		var hit bool
		v := cache.Get(key)
		if v == nil {
			cache.Set(key, key)
		} else {
			hit = true
			if v.(string) != key {
				t.Errorf("cache returned bad data: got %+v , want %+v\n", v, key)
			}
		}
		if hit != wantHit {
			t.Errorf("cache hit mismatch: got %v, want %v\n", hit, wantHit)
		}
	}
}
Пример #15
0
func DiscoverGateway() (ip net.IP, err error) {
	routeCmd := exec.Command("route", "-n", "get", "0.0.0.0")
	stdOut, err := routeCmd.StdoutPipe()
	if err != nil {
		return
	}
	if err = routeCmd.Start(); err != nil {
		return
	}
	output, err := ioutil.ReadAll(stdOut)
	if err != nil {
		return
	}

	// Darwin route out format is always like this:
	//    route to: default
	// destination: default
	//        mask: default
	//     gateway: 192.168.1.1
	outputLines := bytes.Split(output, []byte("\n"))
	for _, line := range outputLines {
		if bytes.Contains(line, []byte("gateway:")) {
			gatewayFields := bytes.Fields(line)
			ip = net.ParseIP(string(gatewayFields[1]))
			break
		}
	}

	err = routeCmd.Wait()
	return
}
Пример #16
0
func (self *Reader) metaSequence(moltype, id string) (sequence *seq.Seq, err error) {
	var line, body []byte

	for {
		if line, err = self.r.ReadBytes('\n'); err == nil {
			if len(line) > 0 && line[len(line)-1] == '\r' {
				line = line[:len(line)-1]
			}
			if len(line) == 0 {
				continue
			}
			if len(line) < 2 || !bytes.HasPrefix(line, []byte("##")) {
				return nil, bio.NewError("Corrupt metasequence", 0, line)
			}
			line = bytes.TrimSpace(line[2:])
			if string(line) == "end-"+moltype {
				break
			} else {
				line = bytes.Join(bytes.Fields(line), nil)
				body = append(body, line...)
			}
		} else {
			return nil, err
		}
	}

	sequence = seq.New(id, body, nil)
	sequence.Moltype = bio.ParseMoltype(moltype)

	return
}
Пример #17
0
func main() {
	languages := []byte("golang haskell ruby python")

	individualLanguages := bytes.Fields(languages)
	log.Printf("Fields split %q on whitespace into %q", languages, individualLanguages)

	vowelsAndSpace := "aeiouy "
	split := bytes.FieldsFunc(languages, func(r rune) bool {
		return strings.ContainsRune(vowelsAndSpace, r)
	})
	log.Printf("FieldsFunc split %q on vowels and space into %q", languages, split)

	space := []byte{' '}
	splitLanguages := bytes.Split(languages, space)
	log.Printf("Split split %q on a single space into %q", languages, splitLanguages)

	numberOfSubslices := 2 // Not number of splits
	singleSplit := bytes.SplitN(languages, space, numberOfSubslices)
	log.Printf("SplitN split %q on a single space into %d subslices: %q", languages, numberOfSubslices, singleSplit)

	splitAfterLanguages := bytes.SplitAfter(languages, space)
	log.Printf("SplitAfter split %q AFTER a single space (keeping the space) into %q", languages, splitAfterLanguages)

	splitAfterNLanguages := bytes.SplitAfterN(languages, space, numberOfSubslices)
	log.Printf("SplitAfterN split %q AFTER a single space (keeping the space) into %d subslices: %q", languages, numberOfSubslices, splitAfterNLanguages)

	languagesBackTogether := bytes.Join(individualLanguages, space)
	log.Printf("Languages are back togeher again! %q == %q? %v", languagesBackTogether, languages, bytes.Equal(languagesBackTogether, languages))
}
Пример #18
0
func parseIndexLine(l []byte) *indexInfo {
	//	fmt.Fprintf (os.Stderr, "Processing line:\n%s\n", l)
	newIndexInfo := indexInfo{}
	var err os.Error
	fields := bytes.Fields(l)
	ptr_cnt, err := strconv.Atoi(string(fields[PTR_CNT]))
	if err != nil {
		fmt.Fprintf(os.Stderr, "I had a problem trying to convert '%s' to int\n", fields[PTR_CNT])
		os.Exit(1)
	}
	newIndexInfo.lemma = fields[LEMMA]
	//	newIndexInfo.pos, err = strconv.Atoui64(string(fields[POS]))
	if len(fields[POS]) > 1 {
		fmt.Fprintf(os.Stderr, "POS has to be 1 letter code ('n', 'v', 'a' or 'r') and I have %s\n", fields[POS])
		os.Exit(1)
	}
	newIndexInfo.pos = fields[POS][0]

	newIndexInfo.tagsense_cnt, err = strconv.Atoi(string(fields[TAGSENSE_CNT+ptr_cnt]))
	if err != nil {
		fmt.Fprintf(os.Stderr, "I had a problem trying to convert %s to int32\n", fields[TAGSENSE_CNT+ptr_cnt])
		os.Exit(1)
	}
	offsets_strs := fields[(SYNSET_OFFSET + ptr_cnt):]
	offsets := make([]int64, len(offsets_strs))
	for i, offset := range offsets_strs {
		offsets[i], err = strconv.Atoi64(string(offset))
		if err != nil {
			fmt.Fprintf(os.Stderr, "I had a problem trying to convert the offset %s to int63\n", offset)
			os.Exit(1) // log.Fatal?
		}
	}
	newIndexInfo.offsets = offsets
	return &newIndexInfo
}
Пример #19
0
func main() {

	ex := make(map[string]entropy.Exact)

	scanner := bufio.NewScanner(os.Stdin)

	var epoch int

	for scanner.Scan() {
		fields := bytes.Fields(scanner.Bytes())

		e, _ := strconv.Atoi(string(fields[0]))
		if e != epoch {
			for k, v := range ex {
				fmt.Println(epoch, k, v.Entropy())
			}

			ex = make(map[string]entropy.Exact)
			epoch = e
		}

		m, ok := ex[string(fields[2])]
		if !ok {
			m = entropy.NewExact()
			ex[string(fields[2])] = m
		}

		m.Push(fields[1], 1)
	}

	for k, v := range ex {
		fmt.Println(epoch, k, v.Entropy())
	}

}
Пример #20
0
func (v *ValueParser) Parse(buf []byte) ([]telegraf.Metric, error) {
	// separate out any fields in the buffer, ignore anything but the last.
	values := bytes.Fields(buf)
	if len(values) < 1 {
		return []telegraf.Metric{}, nil
	}
	valueStr := string(values[len(values)-1])

	var value interface{}
	var err error
	switch v.DataType {
	case "", "int", "integer":
		value, err = strconv.Atoi(valueStr)
	case "float", "long":
		value, err = strconv.ParseFloat(valueStr, 64)
	case "str", "string":
		value = valueStr
	case "bool", "boolean":
		value, err = strconv.ParseBool(valueStr)
	}
	if err != nil {
		return nil, err
	}

	fields := map[string]interface{}{"value": value}
	metric, err := telegraf.NewMetric(v.MetricName, v.DefaultTags,
		fields, time.Now().UTC())
	if err != nil {
		return nil, err
	}

	return []telegraf.Metric{metric}, nil
}
Пример #21
0
// exec `ps` to get all process states
func (p *Processes) gatherFromPS(fields map[string]interface{}) error {
	out, err := p.execPS()
	if err != nil {
		return err
	}

	for i, status := range bytes.Fields(out) {
		if i == 0 && string(status) == "STAT" {
			// This is a header, skip it
			continue
		}
		switch status[0] {
		case 'W':
			fields["wait"] = fields["wait"].(int64) + int64(1)
		case 'U', 'D', 'L':
			// Also known as uninterruptible sleep or disk sleep
			fields["blocked"] = fields["blocked"].(int64) + int64(1)
		case 'Z':
			fields["zombies"] = fields["zombies"].(int64) + int64(1)
		case 'T':
			fields["stopped"] = fields["stopped"].(int64) + int64(1)
		case 'R':
			fields["running"] = fields["running"].(int64) + int64(1)
		case 'S':
			fields["sleeping"] = fields["sleeping"].(int64) + int64(1)
		case 'I':
			fields["idle"] = fields["idle"].(int64) + int64(1)
		default:
			log.Printf("processes: Unknown state [ %s ] from ps",
				string(status[0]))
		}
		fields["total"] = fields["total"].(int64) + int64(1)
	}
	return nil
}
Пример #22
0
func parseIndexLine(l []byte) (*indexInfo, error) {
	//	fmt.Fprintf (os.Stderr, "Processing line:\n%s\n", l)
	newIndexInfo := indexInfo{}
	var err error
	fields := bytes.Fields(l)
	newIndexInfo.lemma = fields[LEMMA]
	//	newIndexInfo.pos, err = strconv.Atoui64(string(fields[POS]))
	if len(fields[POS]) > 1 {
		return nil, ERR_MSG(SYNTACTIC_CATEGORY_TOO_LONG)
	}
	newIndexInfo.pos = fields[POS][0]

	ptr_cnt, err := strconv.Atoi(string(fields[PTR_CNT]))
	if err != nil {
		return nil, err
	}

	ptr_symbols := fields[SYMBOL : SYMBOL+ptr_cnt]
	newIndexInfo.ptr_symbols = ptr_symbols

	newIndexInfo.tagsense_cnt, err = strconv.Atoi(string(fields[TAGSENSE_CNT+ptr_cnt]))
	if err != nil {
		return nil, err
	}
	offsets_strs := fields[(SYNSET_OFFSET + ptr_cnt - 1):]
	offsets := make([]int64, len(offsets_strs))
	for i, offset := range offsets_strs {
		offsets[i], err = strconv.Atoi64(string(offset))
		if err != nil {
			return nil, err
		}
	}
	newIndexInfo.offsets = offsets
	return &newIndexInfo, nil
}
Пример #23
0
func procUsage(pcpu *float64, rss, vss *int64) error {
	contents, err := ioutil.ReadFile(procStatFile)
	if err != nil {
		return err
	}
	fields := bytes.Fields(contents)

	*rss = (parseInt64(fields[rssPos])) << 12
	*vss = parseInt64(fields[vssPos])

	startTime := parseInt64(fields[startPos])
	utime := parseInt64(fields[utimePos])
	stime := parseInt64(fields[stimePos])
	totalTime := utime + stime

	var sysinfo syscall.Sysinfo_t
	if err := syscall.Sysinfo(&sysinfo); err != nil {
		return err
	}

	seconds := int64(sysinfo.Uptime) - (startTime / ticks)

	if seconds > 0 {
		ipcpu := (totalTime * 1000 / ticks) / seconds
		*pcpu = float64(ipcpu) / 10.0
	}

	return nil
}
Пример #24
0
// takes in a byte array representing an edge list and loads the graph
func (g *Graph) LoadEdgeList(edgelist []byte) {
	log.Println(g.Names)
	fields := bytes.Fields(edgelist)
	// create name map from string to index
	log.Println(g.Names)
	names := make(map[string]int)
	for i, n := range g.Names {
		names[n] = i
	}

	// read fields in groups of three: from, to, edgeweight
	for i := 0; i < len(fields)-2; i += 3 {
		from := string(fields[i])
		to := string(fields[i+1])
		weight, err := strconv.ParseFloat(string(fields[i+2]), 64)
		if err != nil {
			log.Println(err)
			continue
		}
		fi, ok := names[from]
		if !ok {
			log.Println("from not ok:", from)
			continue
		}

		ti, ok := names[to]
		if !ok {
			log.Println("to not ok:", to)
			continue
		}

		g.Weights[fi][ti] = weight
	}
}
Пример #25
0
// See word.WrapAsEqualer
func WrapAsEqualer(sb []byte, sorted bool) []ls_core.Equaler {

	sbf := bytes.Fields(sb)
	if sorted {
		sort.Sort(sortBoB(sbf))

		// weed out doublettes
		su, prev := make([][]byte, 0, len(sbf)), []byte{}
		for _, v := range sbf {
			if bytes.Equal(v, prev) {
				continue
			}
			su = append(su, v)
			prev = v
		}
		sbf = su

	}

	ret := make([]ls_core.Equaler, 0, len(sbf))
	for _, v := range sbf {
		cnv := ls_core.Equaler(Token(v))
		ret = append(ret, cnv)
	}
	return ret
}
Пример #26
0
func compareT() {

	fmt.Println(bytes.Compare([]byte("你好"), []byte("你hao")))

	sl := []byte("s '! ' !")
	sli := []byte("'")
	fmt.Println(string(sl), sli,
		bytes.Contains(sl, sli), bytes.Count(sl, sli),
		bytes.Fields(sl), bytes.Fields(sli),
		bytes.Index(sl, sli),
		bytes.Join([][]byte{sl, sli}, []byte("_______________-----")), //php implode
		string(bytes.Replace(sl, []byte("!"), []byte("?"), -1)),
		bytes.Split(sl, []byte("!")),      //php explode
		bytes.SplitAfter(sl, []byte("!")), // 前两个切片包含!
	)
}
Пример #27
0
func DiscoverGateway() (ip net.IP, err error) {
	routeCmd := exec.Command("route", "print", "0.0.0.0")
	stdOut, err := routeCmd.StdoutPipe()
	if err != nil {
		return
	}
	if err = routeCmd.Start(); err != nil {
		return
	}
	output, err := ioutil.ReadAll(stdOut)
	if err != nil {
		return
	}

	// Windows route output format is always like this:
	// ===========================================================================
	// Active Routes:
	// Network Destination        Netmask          Gateway       Interface  Metric
	//           0.0.0.0          0.0.0.0      192.168.1.1    192.168.1.100     20
	// ===========================================================================
	// I'm trying to pick the active route,
	// then jump 2 lines and pick the third IP
	// Not using regex because output is quite standard from Windows XP to 8 (NEEDS TESTING)
	outputLines := bytes.Split(output, []byte("\n"))
	for idx, line := range outputLines {
		if bytes.Contains(line, []byte("Active Routes:")) {
			ipFields := bytes.Fields(outputLines[idx+2])
			ip = net.ParseIP(string(ipFields[2]))
			break
		}
	}
	err = routeCmd.Wait()
	return
}
func main() {
	//Read the input file
	file, err := ioutil.ReadFile("unixdict.txt")
	if err != nil {
		fmt.Println(err)
		return
	}

	//Convert every character to lowercase, as the program is case-insensitive.
	file = bytes.ToLower(file)

	//Anagrams are stored in a map by there sorted string
	anagramMap := make(map[string][]string)
	for _, word := range bytes.Fields(file) {
		wordAsByteSlice := make(byteSlice, len(word))
		copy(wordAsByteSlice, word)
		sort.Sort(wordAsByteSlice)
		sortedString := string(wordAsByteSlice)
		wordString := string(word)
		anagram := append(anagramMap[sortedString], wordString)
		anagramMap[sortedString] = anagram
	}
	for _, anagram := range anagramMap {
		if len(anagram) > 1 {
			fmt.Printf("%s\n", anagram)
		}
	}
}
Пример #29
0
// serveConn is the main loop serving one connection to the proxy.
func serveConn(conn net.Conn, ctx netcontext.Context) {
	defer conn.Close()
	// Use a larger buffer than default to help reading larger memcache
	// values, which can go up to 10^6 bytes (1Mb).
	s := &streams{ctx, bufio.NewReaderSize(conn, 65535), &lineWriter{*bufio.NewWriter(conn)}}
	for {
		line, err := s.in.ReadBytes('\n')
		if err != nil {
			if err != io.EOF {
				log.Printf("ERROR: Client read error: %v", err)
			}
			return
		}
		// Note, to avoid unnecessary allocation that might
		// cause GC pauses we avoid converting to strings
		// except when necessary.
		if args := bytes.Fields(bytes.TrimSpace(line)); len(args) == 0 {
			badCommandf("bogus empty line").writeTo(s)
		} else {
			if err := s.demux(string(args[0]), args[1:]...); err != nil {
				err, ok := err.(memcacheError)
				if !ok { // We don't actually expect this to happen, but let's be paranoid.
					err = serverError{fmt.Errorf("internal problem: %v", err)}
				}
				err.writeTo(s)
			}
		}
		s.out.Flush()
	}
}
Пример #30
0
func parseMovie(movie []byte, m *imdb.Movie) bool {
	// We start backwards and greedily consume the following attributes:
	//     (YYYY) - The year the movie was released.
	//				Everything after (errm, before) this is the title.
	//	   (TV)   - Made for TV
	//	   (V)    - Made for video
	//	   (VG)   - A video game! Skip it.
	var field []byte
	fields := bytes.Fields(movie)
	for i := len(fields) - 1; i >= 0; i-- {
		field = fields[i]
		switch {
		// Try the common case first.
		case hasEntryYear(field):
			err := parseEntryYear(field[1:len(field)-1], &m.Year, &m.Sequence)
			if err != nil {
				pef("Could not convert '%s' to year: %s", field, err)
				return false
			}
			m.Title = unicode(bytes.Join(fields[0:i], []byte{' '}))
			return true
		case bytes.Equal(field, attrVg):
			return false
		case bytes.Equal(field, attrTv):
			m.Tv = true
		case bytes.Equal(field, attrVid):
			m.Video = true
		}
	}
	pef("Could not find title in '%s'.", movie)
	return false
}