Golang FieldsFunc示例

说明

golang fieldsfunc示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: strings

示例#1
文件: main.go 项目: evolsnow/robot

//receive from client
func receive(in string) (ret []string) {
	fmt.Printf("Received: %s\n", in)
	var response string
	var answer = make(chan string, 3)
	sf := func(c rune) bool {
		return c == ',' || c == ',' || c == ';' || c == '。' || c == '.' || c == '?' || c == '?'
	}
	if chinese(in) {
		go func() {
			if ret := iceAI(in); ret != "" {
				answer <- ret
			}
		}()
		go func() {
			if ret := tlAI(in); ret != "" {
				answer <- ret
			}
		}()
		go func() {
			if ret := qinAI(in); ret != "" {
				answer <- strings.Replace(ret, "Jarvis", "samaritan", -1)
			}
		}()
		response = <-answer // accept the first reply
		// Separate into fields with func.
		ret = strings.FieldsFunc(response, sf)

	} else {
		response = mitAI(in)
		ret = strings.FieldsFunc(response, sf)
	}
	return
}

示例#2
文件: version.go 项目: li-ang/godep

// isSameOrNewer go version (goA.B)
// go1.6 >= go1.6 == true
// go1.5 >= go1.6 == false
func isSameOrNewer(base, check string) bool {
	if base == check {
		return true
	}
	if strings.HasPrefix(check, "devel-") {
		return true
	}
	bp := strings.FieldsFunc(base, GoVersionFields)
	cp := strings.FieldsFunc(check, GoVersionFields)
	if len(bp) < 2 || len(cp) < 2 {
		log.Fatalf("Error comparing %s to %s\n", base, check)
	}
	if bp[0] == cp[0] { // We only have go version 1 right now
		bm, err := strconv.Atoi(bp[1])
		// These errors are unlikely and there is nothing nice to do here anyway
		if err != nil {
			panic(err)
		}
		cm, err := strconv.Atoi(cp[1])
		if err != nil {
			panic(err)
		}
		return cm >= bm
	}
	return false
}

示例#3
文件: buildconstraints.go 项目: kc87654321/goxc

// parse and filter list of platforms
func ApplyBuildConstraints(buildConstraints string, unfilteredPlatforms []Platform) []Platform {
	ret := []Platform{}
	items := strings.FieldsFunc(buildConstraints, func(r rune) bool { return r == ' ' })
	if len(items) == 0 {
		return unfilteredPlatforms
	}
	for _, item := range items {
		parts := strings.FieldsFunc(item, func(r rune) bool { return r == ',' })
		itemOs := []string{}
		itemNegOs := []string{}
		itemArch := []string{}
		itemNegArch := []string{}
		for _, part := range parts {
			isNeg, modulus := isNegative(part)
			if IsOs(modulus) {
				if isNeg {
					itemNegOs = append(itemNegOs, modulus)
				} else {
					itemOs = append(itemOs, modulus)
				}
			} else if IsArch(modulus) {
				if isNeg {
					itemNegArch = append(itemNegArch, modulus)
				} else {
					itemArch = append(itemArch, modulus)
				}

			} else {
				log.Printf("Unrecognised build constraint! Ignoring '%s'", part)
			}
		}
		ret = append(ret, resolveItem(itemOs, itemNegOs, itemArch, itemNegArch, unfilteredPlatforms)...)
	}
	return ret
}

示例#4
文件: rules.go 项目: vdemeester/traefik

func (r *Rules) parseRules(expression string, onRule func(functionName string, function interface{}, arguments []string) error) error {
	functions := map[string]interface{}{
		"Host":            r.host,
		"HostRegexp":      r.hostRegexp,
		"Path":            r.path,
		"PathStrip":       r.pathStrip,
		"PathPrefix":      r.pathPrefix,
		"PathPrefixStrip": r.pathPrefixStrip,
		"Method":          r.methods,
		"Headers":         r.headers,
		"HeadersRegexp":   r.headersRegexp,
	}

	if len(expression) == 0 {
		return errors.New("Empty rule")
	}

	f := func(c rune) bool {
		return c == ':'
	}

	// Allow multiple rules separated by ;
	splitRule := func(c rune) bool {
		return c == ';'
	}

	parsedRules := strings.FieldsFunc(expression, splitRule)

	for _, rule := range parsedRules {
		// get function
		parsedFunctions := strings.FieldsFunc(rule, f)
		if len(parsedFunctions) == 0 {
			return errors.New("Error parsing rule: '" + rule + "'")
		}
		functionName := strings.TrimSpace(parsedFunctions[0])
		parsedFunction, ok := functions[functionName]
		if !ok {
			return errors.New("Error parsing rule: '" + rule + "'. Unknown function: '" + parsedFunctions[0] + "'")
		}
		parsedFunctions = append(parsedFunctions[:0], parsedFunctions[1:]...)
		fargs := func(c rune) bool {
			return c == ','
		}
		// get function
		parsedArgs := strings.FieldsFunc(strings.Join(parsedFunctions, ":"), fargs)
		if len(parsedArgs) == 0 {
			return errors.New("Error parsing args from rule: '" + rule + "'")
		}

		for i := range parsedArgs {
			parsedArgs[i] = strings.TrimSpace(parsedArgs[i])
		}

		err := onRule(functionName, parsedFunction, parsedArgs)
		if err != nil {
			return fmt.Errorf("Parsing error on rule: %v", err)
		}
	}
	return nil
}

示例#5
文件: main.go 项目: juju/usso

func openID(w http.ResponseWriter, r *http.Request) {
	r.ParseForm()
	url := *r.URL
	url.Scheme = "http"
	url.Host = "localhost:8080"
	if r.Form.Get("openid.ns") == "" {
		req := openid.Request{
			ReturnTo:     url.String(),
			Teams:        strings.FieldsFunc(*teams, isComma),
			SRegRequired: strings.FieldsFunc(*required, isComma),
			SRegOptional: strings.FieldsFunc(*optional, isComma),
		}
		url := client.RedirectURL(&req)
		http.Redirect(w, r, url, http.StatusFound)
		return
	}
	resp, err := client.Verify(url.String())
	w.Header().Set("ContentType", "text/html")
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		errorTemplate.Execute(w, err)
		return
	}
	loginTemplate.Execute(w, resp)
}

示例#6
文件: main.go 项目: nilium/pinktxt

func parseParameters(params string) Params {
	pairs := strings.FieldsFunc(params, splitQuotedOn(';'))
	r := make(map[string][]string, len(pairs))
	for _, pair := range pairs {
		values := strings.FieldsFunc(pair, splitQuotedOn('=', ','))
		key := values[0]
		if len(pair) == 1 {
			r[key] = append(r[key], "")
			continue
		}
		for i := 1; i < len(values); i++ {
			val := values[i]
			if len(val) > 0 && val[0] == '"' {
				var err error
				val, err = strconv.Unquote(val)
				if err != nil {
					panic(err)
				}
			}

			r[key] = append(r[key], val)
		}
	}
	return Params(r)
}

示例#7
文件: stringsTest.go 项目: upccup/cuplearn

// FieldsFunc splits the string s at each run of Unicode code c satisfying f(c) and returns an array of slices of s.
// if all code points in s satisfy f(c) or the string is empty an empty slice is returned. FieldsFunc makes no guarantees
// about the order in which is calls f(c). if f does not return consistent results for given c FieldsFunc may crash
func FieldsFunc(s string, f func(rune) bool) []string {
	ft := func(c rune) bool {
		return !unicode.IsLetter(c) && !unicode.IsNumber(c)
	}

	fmt.Printf("Field are: %q", strings.FieldsFunc("  foo1;bar2*baz3...", ft)) // Fields are: ["foo1" "bar2" "baz3"]
	return strings.FieldsFunc(s, f)
}

示例#8
文件: comparator.go 项目: conductant/gohm

func ImageLessBySemanticVersion(a, b interface{}) bool {
	imageA, ok := a.(string)
	if !ok {
		return false
	}

	imageB, ok := b.(string)
	if !ok {
		return false
	}

	repoA, tagA, err := ParseDockerImage(imageA)
	if err != nil {
		return false
	}
	repoB, tagB, err := ParseDockerImage(imageB)
	if err != nil {
		return false
	}

	if repoA != repoB {
		return false
	}

	sep := func(c rune) bool { return c == '.' || c == ',' || c == '-' }
	min := func(a, b int) int {
		if a < b {
			return a
		} else {
			return b
		}
	}

	// compare the tags... we tokenize the tags by delimiters such as . and -
	fieldsA := strings.FieldsFunc(tagA, sep)
	fieldsB := strings.FieldsFunc(tagB, sep)
	for i := 0; i < min(len(fieldsA), len(fieldsB)); i++ {
		a, erra := strconv.Atoi(fieldsA[i])
		b, errb := strconv.Atoi(fieldsB[i])
		switch {
		case erra != nil && errb != nil:
			if fieldsA[i] == fieldsB[i] {
				continue
			} else {
				return fieldsA[i] < fieldsB[i]
			}
		case erra == nil && errb == nil:
			if a == b {
				continue
			} else {
				return a < b
			}
		case erra != nil || errb != nil:
			return false
		}
	}
	return false
}

示例#9
文件: autocomplete.go 项目: YouROK/GoProjectManager

func GetLastWord(linesrc string, off int) ([]string, []string) {

	wordsLeft := strings.FieldsFunc(linesrc[:off], func(r rune) bool {
		return !(unicode.IsLetter(r) || unicode.IsDigit(r))
	})

	wordsRight := strings.FieldsFunc(linesrc[off:], func(r rune) bool {
		return !(unicode.IsLetter(r) || unicode.IsDigit(r))
	})

	return wordsLeft, wordsRight
}

示例#10
文件: platforms.go 项目: kc87654321/goxc

// interpret list of destination platforms (based on os & arch settings)
//0.5 add support for space delimiters (similar to BuildConstraints)
//0.5 add support for different oses/services
func GetDestPlatforms(specifiedOses string, specifiedArches string) []Platform {
	destOses := strings.FieldsFunc(specifiedOses, func(r rune) bool { return r == ',' || r == ' ' })
	destArchs := strings.FieldsFunc(specifiedArches, func(r rune) bool { return r == ',' || r == ' ' })

	for _, o := range destOses {
		supported := false
		for _, supportedPlatformArr := range getSupportedPlatforms() {
			supportedOs := supportedPlatformArr.Os
			if o == supportedOs {
				supported = true
			}
		}
		if !supported {
			log.Printf("WARNING: Operating System '%s' is unsupported", o)
		}
	}
	for _, o := range destArchs {
		supported := false
		for _, supportedPlatformArr := range getSupportedPlatforms() {
			supportedArch := supportedPlatformArr.Arch
			if o == supportedArch {
				supported = true
			}
		}
		if !supported {
			log.Printf("WARNING: Architecture '%s' is unsupported", o)
		}
	}
	if len(destOses) == 0 {
		destOses = []string{""}
	}
	if len(destArchs) == 0 {
		destArchs = []string{""}
	}
	var destPlatforms []Platform
	for _, supportedPlatformArr := range getSupportedPlatforms() {
		supportedOs := supportedPlatformArr.Os
		supportedArch := supportedPlatformArr.Arch
		for _, destOs := range destOses {
			if destOs == "" || supportedOs == destOs {
				for _, destArch := range destArchs {
					if destArch == "" || supportedArch == destArch {
						destPlatforms = append(destPlatforms, supportedPlatformArr)
					}
				}
			}
		}
	}
	if len(destPlatforms) < 1 {
		log.Printf("WARNING: no valid platforms specified")
	}
	return destPlatforms
}

示例#11
文件: rules.go 项目: goguardian/traefik

// Parse parses rules expressions
func (r *Rules) Parse(expression string) (*mux.Route, error) {
	functions := map[string]interface{}{
		"Host":            r.host,
		"HostRegexp":      r.hostRegexp,
		"Path":            r.path,
		"PathStrip":       r.pathStrip,
		"PathPrefix":      r.pathPrefix,
		"PathPrefixStrip": r.pathPrefixStrip,
		"Method":          r.methods,
		"Headers":         r.headers,
		"HeadersRegexp":   r.headersRegexp,
	}
	f := func(c rune) bool {
		return c == ':'
	}
	// get function
	parsedFunctions := strings.FieldsFunc(expression, f)
	if len(parsedFunctions) == 0 {
		return nil, errors.New("Error parsing rule: " + expression)
	}
	parsedFunction, ok := functions[parsedFunctions[0]]
	if !ok {
		return nil, errors.New("Error parsing rule: " + expression + ". Unknow function: " + parsedFunctions[0])
	}
	parsedFunctions = append(parsedFunctions[:0], parsedFunctions[1:]...)
	fargs := func(c rune) bool {
		return c == ',' || c == ';'
	}
	// get function
	parsedArgs := strings.FieldsFunc(strings.Join(parsedFunctions, ":"), fargs)
	if len(parsedArgs) == 0 {
		return nil, errors.New("Error parsing args from rule: " + expression)
	}

	inputs := make([]reflect.Value, len(parsedArgs))
	for i := range parsedArgs {
		inputs[i] = reflect.ValueOf(parsedArgs[i])
	}
	method := reflect.ValueOf(parsedFunction)
	if method.IsValid() {
		resultRoute := method.Call(inputs)[0].Interface().(*mux.Route)
		if r.err != nil {
			return nil, r.err
		}
		if resultRoute.GetError() != nil {
			return nil, resultRoute.GetError()
		}
		return resultRoute, nil
	}
	return nil, errors.New("Method not found: " + parsedFunctions[0])
}

示例#12
文件: util.go 项目: heartszhang/famous

func node_style_to_attribute(n *html.Node) {
	style := node_get_attribute(n, "style")
	lines := strings.FieldsFunc(style, func(r rune) bool {
		return strings.ContainsRune(";\n", r)
	})
	for _, line := range lines {
		fields := strings.FieldsFunc(line, func(r rune) bool {
			return strings.ContainsRune(": ", r)
		})
		if len(fields) == 2 {
			node_set_attribute(n, fields[0], fields[1])
		}
	}
}

示例#13
文件: jsonq.go 项目: davidkbainbridge/jsonq

// Recursively query a decoded json blob
func rquery(blob interface{}, s ...string) (interface{}, error) {
	var (
		val interface{}
		err error
	)

	// If there is only a single string argument and if that single string argument has either a "." or a "[" in it
	// the assume it is a path specification and disagregate it into an array of indexes.
	terms := s
	if len(s) == 1 && strings.IndexAny(s[0], ".[]") != -1 {
		terms = strings.FieldsFunc(s[0], func(c rune) bool {
			return c == '.' || c == '[' || c == ']'
		})
	}
	val = blob
	for _, q := range terms {
		val, err = query(val, q)
		if err != nil {
			return nil, err
		}
	}
	switch val.(type) {
	case nil:
		return nil, fmt.Errorf("Nil value found at %s\n", s[len(s)-1])
	}
	return val, nil
}

示例#14
文件: reader.go 项目: taruti/csvutil

//  Attempt to read up to a new line, skipping any comment lines found in
//  the process. Return a Row object containing the fields read and any
//  error encountered.
func (csvr *Reader) ReadRow() Row {
	var (
		r    Row
		line string
	)
	// Read lines until a non-comment line is found.
	for true {
		if line, r.Error = csvr.readLine(); r.Error != nil {
			return r
		}
		csvr.lineNum++
		if !csvr.Comments {
			break
		} else if !csvr.LooksLikeComment(line) {
			break
		} else if csvr.pastHeader && !csvr.CommentsInBody {
			break
		}
	}
	csvr.pastHeader = true

	// Break the line up into fields.
	r.Fields = strings.FieldsFunc(line, func(c rune) bool { return csvr.IsSep(c) })

	// Trim any unwanted characters.
	if csvr.Trim {
		for i := 0; i < len(r.Fields); i++ {
			r.Fields[i] = strings.Trim(r.Fields[i], csvr.Cutset)
		}
	}
	return r
}

示例#15
文件: util.go 项目: ylmbtm/nitori-go

func Args(s string) (result []string) {

	defer func() {
		if recover() != nil {
			result = make([]string, 0, 0)
		}
	}()

	inStr := false
	escape := false
	return strings.FieldsFunc(s, func(r rune) bool {
		if escape {
			escape = false
			return false
		}
		switch r {
		case '\\':
			escape = true
			return false
		case ' ', '\n', '\t':
			return !inStr
		case '"':
			inStr = !inStr
			return true
		default:
			return false
		}
	})
}

示例#16
文件: document.go 项目: ubleipzig/span

// Headings returns subject headings.
func (doc Document) Headings() []string {
	var headings []string
	fields := strings.FieldsFunc(doc.Descriptors, func(r rune) bool {
		return r == ';' || r == '/'
	})
	// refs. #8009
	if len(fields) == 1 {
		fields = strings.FieldsFunc(doc.Descriptors, func(r rune) bool {
			return r == ','
		})
	}
	for _, f := range fields {
		headings = append(headings, strings.TrimSpace(f))
	}
	return headings
}

示例#17
文件: fabric.go 项目: nplanel/skydive

func nodeDefToMetadata(nodeDef string) (string, graph.Metadata, error) {
	f := strings.FieldsFunc(nodeDef, func(r rune) bool {
		return r == '[' || r == ']'
	})
	if len(f) > 2 {
		return "", nil, fmt.Errorf("Unable to parse node definition: %s", nodeDef)
	}

	// by default use the node name as Name metadata attribute
	metadata := graph.Metadata{
		"Name": f[0],
		"Type": "device",
	}

	// parse attributes metadata given
	if len(f) > 1 {
		for _, pair := range strings.Split(f[1], ",") {
			pair = strings.TrimSpace(pair)

			kv := strings.Split(pair, "=")
			if len(kv)%2 != 0 {
				return "", nil, fmt.Errorf("attributes must be defined by pair k=v: %v", nodeDef)
			}
			key := strings.Trim(kv[0], `"`)
			value := strings.Trim(kv[1], `"`)

			metadata[key] = value
		}
	}

	return f[0], metadata, nil
}

示例#18
文件: nbayes.go 项目: VivekNair/GoClassify

func ReadInTrainData( trainString string ) ([]IncrementTable) {

	// =======> NumVariables & NumRows  
	linesFromTrain, err := readLines( trainString )
	fmt.Printf("linesFromTrain is %v, error is %v \n", linesFromTrain, err )
	numVariables, numRows := ReturnFileDetails( linesFromTrain )
	fmt.Printf("numVariables is %v, numRows is %v \n", numVariables, numRows )

	// =======> Read in the values into IncrementTables array
	trainData := make([]IncrementTable, numVariables)
	fmt.Printf("trainData is %v \n", trainData )

	for i := 2; i < int(numRows) + 2; i ++  {
		currentRow := linesFromTrain[i]
		tokenizedString := strings.FieldsFunc( currentRow, delimiter )
		yValue, yErr := strconv.ParseInt(tokenizedString[numVariables], 0, 32)
		fmt.Printf("yValue is %v, yErr is %v \n", yValue, yErr )
		for j := 0; j < int(numVariables); j ++ {
			xValue, xErr := strconv.ParseInt(tokenizedString[j], 0, 32)
			fmt.Printf("xValue is %v, xErr is %v \n", xValue, xErr )
			IncrementInputVariable( &trainData, j,  xValue, yValue )
		}
	}
	return trainData
}

示例#19
文件: chatbox.go 项目: uluyol/misc

func makeWords(q string) []string {
	words := strings.FieldsFunc(q, nonword)
	for i, w := range words {
		words[i] = strings.ToLower(w)
	}
	return words
}

示例#20
文件: slowhttp.go 项目: Clever/go-bench

// Parses a request like "GET /200/500/1000/1500 HTTP/1.1" into 200, 500, 1000, 1500
// Parse errors or missing values are silently ignored and replaced with defaults.
func parseRequest(request string) (responseCode, headerSendTime, bodySendTime int) {
	requestParts := strings.Fields(request)
	requestPathParts := strings.FieldsFunc(requestParts[1], func(r rune) bool { return r == '/' })

	responseCode = DefaultResponseCode
	headerSendTime = DefaultHeaderSendTime
	bodySendTime = DefaultBodySendTime

	if (len(requestPathParts)) >= 1 {
		v, err := strconv.Atoi(requestPathParts[0])
		if err == nil && v >= 0 && v < 1000 {
			responseCode = v
		}
	}

	if (len(requestPathParts)) >= 2 {
		v, err := strconv.Atoi(requestPathParts[1])
		if err == nil && v >= 0 {
			headerSendTime = v
		}
	}

	if (len(requestPathParts)) >= 3 {
		v, err := strconv.Atoi(requestPathParts[2])
		if err == nil && v >= 0 {
			bodySendTime = v
		}
	}

	return // Seriously, Go?
}

示例#21
文件: sentiment.go 项目: postfix/sentiment

// SentimentAnalysis takes in a (possibly 'dirty')
// sentence (or any block of text,) cleans the
// text, finds the sentiment of each word in the
// text, finds the sentiment of the sentence as
// a whole, adn returns an Analysis struct
func (m Models) SentimentAnalysis(sentence string, lang Language) *Analysis {
	if _, ok := m[lang]; !ok {
		lang = English
	}

	analysis := &Analysis{
		Language: lang,
		Words:    []Score{},
		Score:    uint8(0),
	}

	sentences := strings.FieldsFunc(sentence, SplitSentences)
	if len(sentences) > 1 {
		analysis.Sentences = []SentenceScore{}

		for _, s := range sentences {
			analysis.Sentences = append(analysis.Sentences, SentenceScore{
				Sentence: s,
				Score:    m[lang].Predict(s),
			})
		}
	}

	w := strings.Split(sentence, " ")
	for _, word := range w {
		analysis.Words = append(analysis.Words, Score{
			Word:  word,
			Score: m[lang].Predict(word),
		})
	}

	analysis.Score = m[lang].Predict(sentence)

	return analysis
}

示例#22
文件: dbstat.go 项目: njuettner/inspect

// GetVersion collects version information about current instance
// version is of the form '1.2.34-56.7' or '9.8.76a-54.3-log'
// want to represent version in form '1.234567' or '9.876543'
func (s *MysqlStatDBs) GetVersion() {
	res, err := s.Db.QueryReturnColumnDict(versionQuery)
	if err != nil {
		s.Db.Log(err)
		return
	}
	if len(res["VERSION()"]) == 0 {
		return
	}
	version := res["VERSION()"][0]
	//filter out letters
	f := func(r rune) bool {
		if (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') {
			return true
		}
		return false
	}
	version = strings.Join(strings.FieldsFunc(version, f), "")                      //filters out letters from string
	version = strings.Replace(strings.Replace(version, "-", ".", -1), "_", ".", -1) //replaces "_" and "-" with "."
	leading := float64(len(strings.Split(version, ".")[0]))
	version = strings.Replace(version, ".", "", -1)
	ver, err := strconv.ParseFloat(version, 64)
	if err != nil {
		s.Db.Log(err)
	}
	ver /= math.Pow(10.0, (float64(len(version)) - leading))
	s.Metrics.Version.Set(ver)
	return
}

示例#23
文件: main.go 项目: sneha29shukla/mig

func hackTranslateVersion(pkgname string, ver string) string {
	if !strings.HasPrefix(pkgname, "linux-image-generic") {
		return ver
	}

	ffunc := func(c rune) bool {
		if c == '-' {
			return true
		}
		return false
	}
	f := strings.FieldsFunc(ver, ffunc)
	if len(f) != 2 {
		return ver
	}
	ret := f[1]
	idx := strings.Index(ret, ".")
	if idx == -1 {
		return ver
	}
	idx2 := idx + 1
	for _, c := range ret[idx2:] {
		if !unicode.IsDigit(c) {
			break
		}
		idx2++
	}
	ret = f[0] + "." + ret[:idx] + ret[idx2:]

	return ret
}

示例#24
文件: GoServer.go 项目: Bryce86/regret

func init() {
	cfgFile, err := os.Open("./goconf.cfg")
	if err != nil {
		fmt.Println("read config file failed.")
		return
	}
	defer cfgFile.Close()

	br := bufio.NewReader(cfgFile)
	for {
		buff, _, err := br.ReadLine()
		if err != nil {
			if err == io.EOF {
				break
			}

			fmt.Println("ReadLine failed, " + err.Error())
			return
		}

		isSeparator := func(r rune) bool {
			return r == ':'
		}

		ss := strings.FieldsFunc(string(buff), isSeparator)

		if ss[0][0] == '"' {
			continue
		}
		fmt.Println(ss)

		switch ss[0] {
		case "proc":
			proc = ss[1]
			/*
			   case "env":
			   env = ss[1]

			   case "match":
			   match = ss[1]
			*/
		case "logName":
			logName = ss[1]
		case "cmd":
			command = ss[1]
		case "dirpath":
			dirpath = ss[1] + ":" + ss[2]

		default:
			fmt.Println("Invalid config parameter !")
			return
		}
	}

	if proc == "" || /* env == "" || match == "" || */ logName == "" || command == "" || dirpath == "" {
		fmt.Println("Parameters configured incomplete !")
		return
	}
	fmt.Println()
}

示例#25
文件: script_test.go 项目: haowang1013/kaiju

func parseScript(s string) (script.Script, error) {
	m := nameMap()
	scr := script.NewScript()
	words := strings.FieldsFunc(s, func(r rune) bool {
		return r == ' ' || r == '\n' || r == '\t'
	})
	for _, w := range words {
		if allDigit(w) || (w[0] == '-' && allDigit(w[1:])) {
			n, err := strconv.Atoi(w)
			if err != nil {
				return nil, errors.New(fmt.Sprintf("Error parsing integer: %s", w))
			}
			scr.AppendPushInt(int64(n))
		} else if len(w) > 2 && w[:2] == "0x" {
			data, err := hex.DecodeString(w[2:])
			if err != nil {
				return nil, errors.New(fmt.Sprintf("Error parsing hex: %s", w))
			}
			scr.AppendData(data)
		} else if len(w) >= 2 && w[0] == '\'' && w[len(w)-1] == '\'' {
			scr.AppendPushData([]byte(w[1 : len(w)-1]))
		} else if op, ok := m[w]; ok {
			scr.AppendOp(op)
		} else {
			return nil, errors.New(fmt.Sprintf("Error parsing unknown word: %s", w))
		}
	}
	return *scr, nil
}

示例#26
文件: provider.go 项目: vdemeester/traefik

func normalize(name string) string {
	fargs := func(c rune) bool {
		return !unicode.IsLetter(c) && !unicode.IsNumber(c)
	}
	// get function
	return strings.Join(strings.FieldsFunc(name, fargs), "-")
}

示例#27
文件: couch2csv.go 项目: dustin/web-thermometer

func parseTime(in string) (time.Time, error) {
	parts := strings.FieldsFunc(in, func(r rune) bool {
		return r == '/' || r == '-' || r == ':' || r == 'T' ||
			r == ' ' || r == '.'
	})

	if len(parts) < 6 {
		return time.Time{},
			fmt.Errorf("Incorrect number of fields: %#v", parts)
	}

	np := []int{}
	for _, p := range parts {
		x, err := strconv.Atoi(p)
		if err != nil {
			return time.Time{}, errors.New("Unparsable time")
		}
		np = append(np, x)
	}

	nsec := 0
	if len(np) > 6 {
		nsec = np[6] * 1000
	}

	return time.Date(np[0], time.Month(np[1]), np[2],
		np[3], np[4], np[5], nsec, time.Local), nil
}

示例#28
文件: datastructures.go 项目: kballard/goirc

func parseLine(input string) (line Line) {
	line.Raw = input
	line.Time = time.Now()
	// quick sanity check
	if len(input) == 0 || input[0] == ' ' {
		return
	}
	// split input, first into "prefix :suffix", and then tokenize prefix
	comps := strings.SplitN(input, " :", 2)
	input = comps[0]
	words := strings.FieldsFunc(input, func(r rune) bool { return r == ' ' })
	if len(words) == 0 {
		// where's my prefix/command?
		return
	} else if words[0][0] == ':' {
		// it has the expected sender prefix
		line.Src = parseUser(words[0][1:])
		words = words[1:]
	}
	if len(words) == 0 {
		// where's my command?
		return
	}
	line.Command = words[0]
	words = words[1:]
	if len(comps) > 1 {
		words = append(words, comps[1])
	}
	line.Args = words
	return
}

示例#29
文件: tools.go 项目: vassilux/vorimport

func getPeerFromChannel(channel string) (peer string) {
	if strings.Contains(channel, "IAX2/trunk_") {
		return ""
	}

	//try to find the destination from channel
	delim := '-'
	if strings.Contains(channel, "@") {
		delim = '@'
	}

	w := strings.FieldsFunc(channel, func(r rune) bool {
		switch r {

		case '/', delim:
			return true
		}
		return false
	})

	if len(w) >= 3 {
		return w[len(w)-2]
	} else {
		return channel
	}

}

示例#30
文件: wc.go 项目: gitter-badger/haze-kv

// our simplified version of MapReduce does not supply a
// key to the Map function, as in the paper; only a value,
// which is a part of the input file content. the return
// value should be a list of key/value pairs, each represented
// by a mapreduce.KeyValue.
func Map(value string) *list.List {

	f := func(c rune) bool {
		return !unicode.IsLetter(c) && !unicode.IsNumber(c)
	}

	s := strings.FieldsFunc(value, f)
	l := list.New()
	m := make(map[string]string)
	for _, k := range s {
		if v, exsits := m[k]; exsits != false {
			v += "1"
			m[k] = v
		} else {
			m[k] = "1"
		}
	}

	for k, v := range m {
		//fmt.Println(v)//XXX for test
		kv := mapreduce.NewKeyValue(k, v)
		l.PushBack(kv)
	}

	return l
}

展开阅读全文