Golang EqualFold示例

说明

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

编程语言: Golang

命名空间/包名称: strings

示例#1
文件: subr.go 项目: 2thetop/go

// lookdot0 returns the number of fields or methods named s associated
// with Type t. If exactly one exists, it will be returned in *save
// (if save is not nil).
func lookdot0(s *Sym, t *Type, save **Field, ignorecase bool) int {
	u := t
	if u.IsPtr() {
		u = u.Elem()
	}

	c := 0
	if u.IsStruct() || u.IsInterface() {
		for _, f := range u.Fields().Slice() {
			if f.Sym == s || (ignorecase && f.Type.Etype == TFUNC && f.Type.Recv() != nil && strings.EqualFold(f.Sym.Name, s.Name)) {
				if save != nil {
					*save = f
				}
				c++
			}
		}
	}

	u = methtype(t, 0)
	if u != nil {
		for _, f := range u.Methods().Slice() {
			if f.Embedded == 0 && (f.Sym == s || (ignorecase && strings.EqualFold(f.Sym.Name, s.Name))) {
				if save != nil {
					*save = f
				}
				c++
			}
		}
	}

	return c
}

示例#2
文件: steaminfo_test.go 项目: syncore/a2sapi

func TestParseServerInfo(t *testing.T) {
	data := []byte{
		0xFF, 0xFF, 0xFF, 0xFF, 0x49, 0x11, 0x71, 0x6C, 0x2E, 0x73, 0x79, 0x6E,
		0x63, 0x6F, 0x72, 0x65, 0x2E, 0x6F, 0x72, 0x67, 0x20, 0x2D, 0x20, 0x55,
		0x53, 0x20, 0x43, 0x45, 0x4E, 0x54, 0x52, 0x41, 0x4C, 0x20, 0x23, 0x31,
		0x00, 0x74, 0x68, 0x75, 0x6E, 0x64, 0x65, 0x72, 0x73, 0x74, 0x72, 0x75,
		0x63, 0x6B, 0x00, 0x62, 0x61, 0x73, 0x65, 0x71, 0x33, 0x00, 0x43, 0x6C,
		0x61, 0x6E, 0x20, 0x41, 0x72, 0x65, 0x6E, 0x61, 0x00, 0x00, 0x00, 0x02,
		0x10, 0x00, 0x64, 0x6C, 0x00, 0x01, 0x31, 0x30, 0x36, 0x33, 0x00, 0xB1,
		0x38, 0x6D, 0x02, 0xF8, 0xC1, 0x4D, 0x7B, 0x17, 0x40, 0x01, 0x63, 0x6C,
		0x61, 0x6E, 0x61, 0x72, 0x65, 0x6E, 0x61, 0x2C, 0x73, 0x79, 0x6E, 0x63,
		0x6F, 0x72, 0x65, 0x2C, 0x74, 0x65, 0x78, 0x61, 0x73, 0x00, 0x48, 0x4F,
		0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
	sinfo, err := parseServerInfo(data)
	if err != nil {
		t.Fatalf("Unexpected error when parsing server info")
	}
	if !strings.EqualFold(sinfo.Name, "ql.syncore.org - US CENTRAL #1") {
		t.Fatalf("Expected server name: ql.syncore.org - US CENTRAL #1 got: %s",
			sinfo.Name)
	}
	if !strings.EqualFold(sinfo.Environment, "Linux") {
		t.Fatalf("Expected server environment: Linux got: %s",
			sinfo.Environment)
	}
	if sinfo.Players != 2 {
		t.Fatalf("Expected server to contain 2 players, got: %d", sinfo.Players)
	}
	if !strings.EqualFold(sinfo.Folder, "baseq3") {
		t.Fatalf("Expected server's game folder to be baseq3, got: %s", sinfo.Folder)
	}
}

示例#3
文件: discovery.go 项目: blaggacao/godoo

// parseMetaGoImports returns meta imports from the HTML in r.
// Parsing ends at the end of the <head> section or the beginning of the <body>.
func parseMetaGoImports(r io.Reader) (imports []metaImport) {
	d := xml.NewDecoder(r)
	d.Strict = false
	for {
		t, err := d.Token()
		if err != nil {
			return
		}
		if e, ok := t.(xml.StartElement); ok && strings.EqualFold(e.Name.Local, "body") {
			return
		}
		if e, ok := t.(xml.EndElement); ok && strings.EqualFold(e.Name.Local, "head") {
			return
		}
		e, ok := t.(xml.StartElement)
		if !ok || !strings.EqualFold(e.Name.Local, "meta") {
			continue
		}
		if attrValue(e.Attr, "name") != "go-import" {
			continue
		}
		if f := strings.Fields(attrValue(e.Attr, "content")); len(f) == 3 {
			imports = append(imports, metaImport{
				Prefix:   f[0],
				VCS:      f[1],
				RepoRoot: f[2],
			})
		}
	}
	return
}

示例#4
文件: context.go 项目: cloudnautique/rancher-compose

func (c *Context) LoadEnv() (*rancherClient.Environment, error) {
	if c.Environment != nil {
		return c.Environment, nil
	}

	projectName := c.sanitizedProjectName()
	if _, err := c.loadClient(); err != nil {
		return nil, err
	}

	logrus.Debugf("Looking for stack %s", projectName)
	// First try by name
	envs, err := c.Client.Environment.List(&rancherClient.ListOpts{
		Filters: map[string]interface{}{
			"name":         projectName,
			"removed_null": nil,
		},
	})
	if err != nil {
		return nil, err
	}

	for _, env := range envs.Data {
		if strings.EqualFold(projectName, env.Name) {
			logrus.Debugf("Found stack: %s(%s)", env.Name, env.Id)
			c.Environment = &env
			return c.Environment, nil
		}
	}

	// Now try not by name for case sensitive databases
	envs, err = c.Client.Environment.List(&rancherClient.ListOpts{
		Filters: map[string]interface{}{
			"removed_null": nil,
		},
	})
	if err != nil {
		return nil, err
	}

	for _, env := range envs.Data {
		if strings.EqualFold(projectName, env.Name) {
			logrus.Debugf("Found stack: %s(%s)", env.Name, env.Id)
			c.Environment = &env
			return c.Environment, nil
		}
	}

	logrus.Infof("Creating stack %s", projectName)
	env, err := c.Client.Environment.Create(&rancherClient.Environment{
		Name: projectName,
	})
	if err != nil {
		return nil, err
	}

	c.Environment = env

	return c.Environment, nil
}

示例#5
文件: main.go 项目: ashanbrown/influxdb

func (c *CommandLine) Insert(stmt string) error {
	i, point := parseNextIdentifier(stmt)
	if !strings.EqualFold(i, "insert") {
		fmt.Printf("ERR: found %s, expected INSERT\n", i)
		return nil
	}
	if i, r := parseNextIdentifier(point); strings.EqualFold(i, "into") {
		point = c.parseInto(r)
	}
	_, err := c.Client.Write(client.BatchPoints{
		Points: []client.Point{
			client.Point{Raw: point},
		},
		Database:         c.Database,
		RetentionPolicy:  c.RetentionPolicy,
		Precision:        "n",
		WriteConsistency: c.WriteConsistency,
	})
	if err != nil {
		fmt.Printf("ERR: %s\n", err)
		if c.Database == "" {
			fmt.Println("Note: error may be due to not setting a database or retention policy.")
			fmt.Println(`Please set a database with the command "use <database>" or`)
			fmt.Println("INSERT INTO <database>.<retention-policy> <point>")
		}
		return err
	}
	return nil
}

示例#6
文件: envconf.go 项目: kitcambridge/envconf

// DecodeStrict returns an error if env contains prefixed variables that do not
// correspond to either field names in v, or keys in ignoreEnv.
func (env Environment) DecodeStrict(prefix, sep string, v interface{},
	ignoreEnv map[string]interface{}) error {

	var fields []string
	if err := env.decode(prefix, sep, v, &fields); err != nil {
		return err
	}
getEnv:
	for key := range env {
		if !hasPrefixFold(key, prefix) {
			continue
		}
		if _, ok := ignoreEnv[key]; ok {
			continue
		}
		for _, field := range fields {
			if strings.EqualFold(key, field) {
				continue getEnv
			}
		}
		for field := range ignoreEnv {
			if strings.EqualFold(key, field) {
				continue getEnv
			}
		}
		return fmt.Errorf("Unrecognized environment variable '%s'", key)
	}
	return nil
}

示例#7
文件: event.go 项目: strogo/newshound

// checks if partial is any of the words or phrases within whole
func phrasesMatch(partial, whole string) bool {
	// create words of whole
	words := strings.Fields(whole)
	// tag partial apart and put it back together with standard space
	partials := strings.Fields(partial)
	partialWords := len(partials)
	partial = strings.Join(partials, " ")
	// check if partial matches any of whole's phrases
	for i := 0; (i + partialWords) <= len(words); i++ {

		slidingBit := strings.Join(words[i:(i+partialWords)], " ")

		if strings.EqualFold(slidingBit, partial) {
			return true
		}

		if strings.HasSuffix(slidingBit, "'s") {
			if strings.EqualFold(strings.TrimSuffix(slidingBit, "'s"), partial) {
				return true
			}
		}
	}

	return false
}

示例#8
文件: channeldetail.go 项目: MiteshSharma/go-socialengine

func Read(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	requestType := r.FormValue("request_type")
	channelIdStr := r.FormValue("channel_id")
	userId := context.Get(r, "user_id").(int)

	var channelDetails []channeldetail.ChannelDetail

	if strings.EqualFold(requestType, "id") {
		channelDetails = channeldetail.Read(userId)
	} else if strings.EqualFold(requestType, "channel") {
		if helper.IsValidRequest(channelIdStr) {
			channelId, _ := strconv.Atoi(channelIdStr)
			channelDetails = channeldetail.ReadByChannel(channelId)
		}
	} else {
		channelDetails = nil
	}
	if channelDetails != nil {
		responseJson, responseCode := helper.GetResponseJson(channelDetails)
		middleware.Output.Response = responseJson
		middleware.Output.ResponseCode = responseCode
	} else {
		middleware.Output.ResponseCode = http.StatusBadRequest
	}
}

示例#9
文件: logspout.go 项目: robeferre/deis

func syslogStreamer(target Target, types []string, logstream chan *Log) {
	typestr := "," + strings.Join(types, ",") + ","
	for logline := range logstream {
		if typestr != ",," && !strings.Contains(typestr, logline.Type) {
			continue
		}
		tag, pid := getLogName(logline.Name)
		var conn net.Conn
		if strings.EqualFold(target.Protocol, "tcp") {
			addr, err := net.ResolveTCPAddr("tcp", target.Addr)
			assert(err, "syslog")
			tcpconn, err := net.DialTCP("tcp", nil, addr)
			assert(err, "syslog")
			assert(tcpconn.SetWriteBuffer(1048576), "syslog")
			conn = tcpconn
		} else if strings.EqualFold(target.Protocol, "udp") {
			addr, err := net.ResolveUDPAddr("udp", target.Addr)
			assert(err, "syslog")
			udpconn, err := net.DialUDP("udp", nil, addr)
			assert(err, "syslog")
			assert(udpconn.SetWriteBuffer(1048576), "syslog")
			conn = udpconn
		} else {
			assert(fmt.Errorf("%s is not a supported protocol, use either udp or tcp", target.Protocol), "syslog")
		}
		// HACK: Go's syslog package hardcodes the log format, so let's send our own message
		_, err := fmt.Fprintf(conn,
			"%s %s[%s]: %s",
			time.Now().Format(getopt("DATETIME_FORMAT", dtime.DeisDatetimeFormat)),
			tag,
			pid,
			logline.Data)
		assert(err, "syslog")
	}
}

示例#10
文件: dqsj.go 项目: 424626154/Qax580_GoServer

func chackDqsjAccount(ctx *context.Context) (bool, string) {
	ck, err := ctx.Request.Cookie(DQSJ_USERNAME)
	if err != nil {
		return false, ""
	}

	username := ck.Value

	ck, err = ctx.Request.Cookie(DQSJ_PASSWORD)
	if err != nil {
		return false, ""
	}

	password := ck.Value

	admin, err := models.GetOneDqsjAdmin(username)
	beego.Debug("GetOneDqsjAdmin admin:", admin)
	if err != nil {
		return false, ""
	}
	if admin != nil && strings.EqualFold(username, admin.Username) && strings.EqualFold(password, admin.Password) {
		beego.Debug(" cookie username ", username)
		return true, username
	} else {
		return false, username
	}

}

示例#11
文件: linuxcgroupspath_v0.1.1.go 项目: WeiZhang555/oct

func testCgroupspath(linuxSpec *specs.LinuxSpec, linuxRuntimeSpec *specs.LinuxRuntimeSpec) (string, error) {
	configFile := "./config.json"
	runtimeFile := "./runtime.json"
	// check whether the container mounts Cgroup filesystem and get the mount point
	hasCgFs := false
	var cgmnt string
	for k, v := range linuxRuntimeSpec.RuntimeSpec.Mounts {
		if strings.EqualFold(v.Type, "cgroup") {
			hasCgFs = true
			for _, u := range linuxSpec.Spec.Mounts {
				if strings.EqualFold(u.Name, k) {
					cgmnt = u.Path
				}
			}
		}
	}
	if hasCgFs == false {
		return manager.UNSPPORTED, errors.New("Container doesn't support cgroup")
	}
	linuxSpec.Spec.Process.Args = []string{"/bin/bash", "-c", "find " + cgmnt + "/ -name " + linuxRuntimeSpec.Linux.CgroupsPath}
	err := configconvert.LinuxSpecToConfig(configFile, linuxSpec)
	err = configconvert.LinuxRuntimeToConfig(runtimeFile, linuxRuntimeSpec)
	out, err := adaptor.StartRunc(configFile, runtimeFile)
	if err != nil {
		return manager.UNKNOWNERR, errors.New("StartRunc error :" + out + "," + err.Error())
	} else if strings.Contains(out, linuxRuntimeSpec.Linux.CgroupsPath) {
		return manager.PASSED, nil
	} else {
		return manager.FAILED, errors.New("may be NOT SUPPORT setting cgrouppath")
	}
}

示例#12
文件: main.go 项目: yasker/host-api

func getConnectionToken(try int, tokenReq *rclient.HostApiProxyToken, rancherClient *rclient.RancherClient) (*rclient.HostApiProxyToken, error) {
	if try >= maxWaitOnHostTries {
		return nil, fmt.Errorf("Reached max retry attempts for getting token.")
	}

	tokenResponse, err := rancherClient.HostApiProxyToken.Create(tokenReq)
	if err != nil {
		if apiError, ok := err.(*rclient.ApiError); ok {
			if apiError.StatusCode == 422 {
				parsed := &ParsedError{}
				if uErr := json.Unmarshal([]byte(apiError.Body), &parsed); uErr == nil {
					if strings.EqualFold(parsed.Code, "InvalidReference") && strings.EqualFold(parsed.FieldName, "reportedUuid") {
						logrus.WithField("reportedUuid", config.Config.HostUuid).WithField("Attempt", try).Infof("Host not registered yet. Sleeping 1 second and trying again.")
						time.Sleep(time.Second)
						try += 1
						return getConnectionToken(try, tokenReq, rancherClient) // Recursion!
					}
				} else {
					return nil, uErr
				}
			} else if apiError.StatusCode == 501 {
				logrus.Infof("Host-api proxy disabled. Will not connect.")
				return nil, nil
			}
			return nil, err
		}
	}
	return tokenResponse, nil
}

示例#13
文件: passwordadmin.go 项目: wulinxu/KeyAdmin-go

func GenerateKey(passpharse []byte, config ConfigType) (err error) {
	pubBlock, priBlock, err := _generateKey(passpharse, config)
	if err != nil {
		return
	}

	pubkeyOut, err := os.OpenFile(config.PublicKeyDir, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
	if err != nil {
		if strings.EqualFold(config.PublicKeyDir, "") {
			pubkeyOut = os.Stdout
		} else {
			return
		}

	}
	prikeyOut, err := os.OpenFile(config.PrivateKeyDir, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
	if err != nil {
		if strings.EqualFold(config.PrivateKeyDir, "") {
			prikeyOut = os.Stdout
		} else {
			return
		}
	}
	err = pem.Encode(pubkeyOut, pubBlock)

	if err != nil {
		return
	}
	err = pem.Encode(prikeyOut, priBlock)
	return
}

示例#14
文件: transmissions.go 项目: SparkPost/gosparkpost

// ParseContent asserts that Transmission.Content is valid.
func ParseContent(content interface{}) (err error) {
	switch rVal := content.(type) {
	case map[string]interface{}:
		for k, v := range rVal {
			switch vVal := v.(type) {
			case string:
				if strings.EqualFold(k, "template_id") {
					return nil
				}
			default:
				return fmt.Errorf("Transmission.Content objects must contain string values, not [%s]", reflect.TypeOf(vVal))
			}
		}
		return fmt.Errorf("Transmission.Content objects must contain a key `template_id`")

	case map[string]string:
		for k, _ := range rVal {
			if strings.EqualFold(k, "template_id") {
				return nil
			}
		}
		return fmt.Errorf("Transmission.Content objects must contain a key `template_id`")

	case Content:
		te := &Template{Name: "tmp", Content: rVal}
		return te.Validate()

	default:
		return fmt.Errorf("Unsupported Transmission.Content type [%s]", reflect.TypeOf(rVal))
	}

	return
}

示例#15
文件: key_test.go 项目: jamesbjackson/cfssl

func TestEcKeyErrors(t *testing.T) {
	k := Key{
		module:     &mockCtx{},
		tokenLabel: "token label",
		pin:        "unused",
	}

	// Trying to load private EC key with no public key
	err := k.setup("no_public_key_ec")
	if err == nil {
		t.Errorf("Unexpected success")
	}
	if !strings.EqualFold(err.Error(), "public key not found") {
		t.Errorf("Unexpected error value: %v", err)
	}

	// Trying to load private EC key with invalid EC point
	err = k.setup("invalid_ec_point")
	if err == nil {
		t.Errorf("Unexpected success")
	}
	if !strings.EqualFold(err.Error(), "invalid EC Point") {
		t.Errorf("Unexpected error value: %v", err)
	}
}

示例#16
文件: infer.go 项目: bww/go-fetch

/**
 * Exclude sources that look private (e.g., start with '.', '_'; are a directory known
 * to be used by a dependency manager; are a test file (with suffix '_test.go'); or are
 * otherwise known to be problematic for some reason)
 */
func looksPrivateSourceFilter(n string) bool {
	ts := "_test.go"

	base := path.Base(n)
	switch {
	case len(base) < 1 || base[0] == '.' || base[0] == '_':
		return false
	case len(base) > len(ts) && strings.EqualFold(base[:len(base)-len(ts)], ts):
		return false
	case strings.EqualFold(base, "vendor"):
		return false
	case strings.EqualFold(base, "Godep"):
		return false
	case strings.EqualFold(base, "third_party"):
		return false
	case strings.EqualFold(base, "pkg"):
		return false
	}

	for _, e := range defaultExcludePackages {
		if strings.HasSuffix(n, e) {
			return false
		}
	}

	return true
}

示例#17
文件: frcscrape.go 项目: samuelcouch/frcscrape

func ScrapeTeamsForEvent(eventCode string, year int) ([]string, error) {
	var url string
	for event := range cmpStrings {
		if strings.EqualFold(strings.ToLower(eventCode), event) {
			url = fmt.Sprintf("https://my.usfirst.org/myarea/index.lasso?page=teamlist&event_type=FRC&sort_teams=number&year=%d&event=cmp&division=%s", year, cmpStrings[event])
			break
		}
	}
	if strings.EqualFold(url, "") {
		url = fmt.Sprintf("https://my.usfirst.org/myarea/index.lasso?page=teamlist&event_type=FRC&sort_teams=number&year=%d&event=%s", year, eventCode)
	}

	doc, err := getDoc(url)
	if err != nil {
		return nil, err
	}

	tds := doc.Find("tr").FilterFunction(func(i int, s *goquery.Selection) bool {
		t := s.Find("td")
		return t.Length() > 0
	})

	if tds.Length() <= 3 {
		return nil, ErrNoData
	}

	m := []string{}

	tds.Slice(3, tds.Length()).Each(func(i int, s *goquery.Selection) {
		info := s.Find("td")
		team := trimWhitespace(info.Eq(2).Text())
		m = append(m, team)
	})
	return m, nil
}

示例#18
文件: wf.go 项目: bruceadowns/vropsbot

// Handles returns whether this plugin will handle the given parameters
func (plugin *wf) Handles(req *comm.Request) bool {
	if len(req.Arguments) < 3 ||
		len(req.Arguments) > 5 {
		return false
	}

	if !strings.EqualFold(req.Arguments[0], "vro") {
		return false
	}

	if !strings.EqualFold(req.Arguments[1], "workflow") &&
		!strings.EqualFold(req.Arguments[1], "wf") {
		return false
	}

	if _, err := strconv.Atoi(req.Arguments[2]); err != nil {
		return false
	}

	if len(req.Arguments) > 3 &&
		!strings.EqualFold(req.Arguments[3], "ob") &&
		!strings.EqualFold(req.Arguments[3], "sb") {
		return false
	}

	return true
}

示例#19
文件: context.go 项目: rancher/rancher-catalog-service

func (c *Context) LoadStack() (*client.Stack, error) {
	if c.Stack != nil {
		return c.Stack, nil
	}

	projectName := c.sanitizedProjectName()
	if _, err := c.loadClient(); err != nil {
		return nil, err
	}

	logrus.Debugf("Looking for stack %s", projectName)
	// First try by name
	stacks, err := c.Client.Stack.List(&client.ListOpts{
		Filters: map[string]interface{}{
			"name":         projectName,
			"removed_null": nil,
		},
	})
	if err != nil {
		return nil, err
	}

	for _, stack := range stacks.Data {
		if strings.EqualFold(projectName, stack.Name) {
			logrus.Debugf("Found stack: %s(%s)", stack.Name, stack.Id)
			c.Stack = &stack
			return c.Stack, nil
		}
	}

	// Now try not by name for case sensitive databases
	stacks, err = c.Client.Stack.List(&client.ListOpts{
		Filters: map[string]interface{}{
			"removed_null": nil,
		},
	})
	if err != nil {
		return nil, err
	}

	for _, stack := range stacks.Data {
		if strings.EqualFold(projectName, stack.Name) {
			logrus.Debugf("Found stack: %s(%s)", stack.Name, stack.Id)
			c.Stack = &stack
			return c.Stack, nil
		}
	}

	logrus.Infof("Creating stack %s", projectName)
	stack, err := c.Client.Stack.Create(&client.Stack{
		Name: projectName,
	})
	if err != nil {
		return nil, err
	}

	c.Stack = stack

	return c.Stack, nil
}

示例#20
文件: commands.go 项目: slugalisk/go-twitch-logger

func HandleMessage(ws *WSConn, ch <-chan Message) {
	defer log.Println("loop closed somehow")
	channels := slurpFile("channels.txt")
	for {
		m := <-ch
		d := s.Split(m.Data, " ")
		ld := s.Split(s.ToLower(m.Data), " ")
		if m.Nick == "dbc__" || m.Nick == "tenseyi" {
			switch m.Command {
			case "MSG":
				if s.EqualFold(d[0], "!join") {
					if !inSlice(ld[1], channels) {
						channels = append(channels, ld[1])
						writeFile("channels.txt", channels)
						ws.Write("JOIN #" + ld[1])
						ws.Write("PRIVMSG #" + m.Channel + " :Logging " + ld[1])
					}
					ws.Write("PRIVMSG #" + m.Channel + " :Already logging " + ld[1])
					continue
				}
				if s.EqualFold(d[0], "!leave") {
					if inSlice(ld[1], channels) {
						channels = remove(ld[1], channels)
						writeFile("channels.txt", channels)
						ws.Write("PART #" + ld[1])
						ws.Write("PRIVMSG #" + m.Channel + " :Leaving " + ld[1])
					}
				}
			}
		}
	}
}

示例#21
文件: get_http.go 项目: partamonov/terraform

// parseMeta looks for the first meta tag in the given reader that
// will give us the source URL.
func (g *HttpGetter) parseMeta(r io.Reader) (string, error) {
	d := xml.NewDecoder(r)
	d.CharsetReader = charsetReader
	d.Strict = false
	var err error
	var t xml.Token
	for {
		t, err = d.Token()
		if err != nil {
			if err == io.EOF {
				err = nil
			}
			return "", err
		}
		if e, ok := t.(xml.StartElement); ok && strings.EqualFold(e.Name.Local, "body") {
			return "", nil
		}
		if e, ok := t.(xml.EndElement); ok && strings.EqualFold(e.Name.Local, "head") {
			return "", nil
		}
		e, ok := t.(xml.StartElement)
		if !ok || !strings.EqualFold(e.Name.Local, "meta") {
			continue
		}
		if attrValue(e.Attr, "name") != "terraform-get" {
			continue
		}
		if f := attrValue(e.Attr, "content"); f != "" {
			return f, nil
		}
	}
}

示例#22
文件: api.go 项目: Nitron/packer

func (d DigitalOceanClient) Image(slug_or_name_or_id string) (Image, error) {
	images, err := d.Images()
	if err != nil {
		return Image{}, err
	}

	for _, image := range images {
		if strings.EqualFold(image.Slug, slug_or_name_or_id) {
			return image, nil
		}
	}

	for _, image := range images {
		if strings.EqualFold(image.Name, slug_or_name_or_id) {
			return image, nil
		}
	}

	for _, image := range images {
		id, err := strconv.Atoi(slug_or_name_or_id)
		if err == nil {
			if image.Id == uint(id) {
				return image, nil
			}
		}
	}

	err = errors.New(fmt.Sprintf("Unknown image '%v'", slug_or_name_or_id))

	return Image{}, err
}

示例#23
文件: h2i.go 项目: rtewalt/etcd

func (a *h2i) cmdSettings(args []string) error {
	if len(args) == 1 && strings.EqualFold(args[0], "ACK") {
		return a.framer.WriteSettingsAck()
	}
	var settings []http2.Setting
	for _, arg := range args {
		if strings.EqualFold(arg, "ACK") {
			a.logf("Error: ACK must be only argument with the SETTINGS command")
			return nil
		}
		eq := strings.Index(arg, "=")
		if eq == -1 {
			a.logf("Error: invalid argument %q (expected SETTING_NAME=nnnn)", arg)
			return nil
		}
		sid, ok := settingByName(arg[:eq])
		if !ok {
			a.logf("Error: unknown setting name %q", arg[:eq])
			return nil
		}
		val, err := strconv.ParseUint(arg[eq+1:], 10, 32)
		if err != nil {
			a.logf("Error: invalid argument %q (expected SETTING_NAME=nnnn)", arg)
			return nil
		}
		settings = append(settings, http2.Setting{
			ID:  sid,
			Val: uint32(val),
		})
	}
	a.logf("Sending: %v", settings)
	return a.framer.WriteSettings(settings...)
}

示例#24
文件: api.go 项目: Nitron/packer

func (d DigitalOceanClient) Region(slug_or_name_or_id string) (Region, error) {
	regions, err := d.Regions()
	if err != nil {
		return Region{}, err
	}

	for _, region := range regions {
		if strings.EqualFold(region.Slug, slug_or_name_or_id) {
			return region, nil
		}
	}

	for _, region := range regions {
		if strings.EqualFold(region.Name, slug_or_name_or_id) {
			return region, nil
		}
	}

	for _, region := range regions {
		id, err := strconv.Atoi(slug_or_name_or_id)
		if err == nil {
			if region.Id == uint(id) {
				return region, nil
			}
		}
	}

	err = errors.New(fmt.Sprintf("Unknown region '%v'", slug_or_name_or_id))

	return Region{}, err
}

示例#25
文件: main_test.go 项目: rpio/resin-supervisor

func TestReadConfig(t *testing.T) {
	if config, err := ReadConfig("config_for_test.json"); err != nil {
		t.Error(err)
	} else if !strings.EqualFold(config.ApplicationId, "1939") || !strings.EqualFold(config.ApiKey, "SuperSecretAPIKey") {
		t.Error("Config not parsed correctly")
	}
}

示例#26
文件: api.go 项目: Nitron/packer

func (d DigitalOceanClient) Size(slug_or_name_or_id string) (Size, error) {
	sizes, err := d.Sizes()
	if err != nil {
		return Size{}, err
	}

	for _, size := range sizes {
		if strings.EqualFold(size.Slug, slug_or_name_or_id) {
			return size, nil
		}
	}

	for _, size := range sizes {
		if strings.EqualFold(size.Name, slug_or_name_or_id) {
			return size, nil
		}
	}

	for _, size := range sizes {
		id, err := strconv.Atoi(slug_or_name_or_id)
		if err == nil {
			if size.Id == uint(id) {
				return size, nil
			}
		}
	}

	err = errors.New(fmt.Sprintf("Unknown size '%v'", slug_or_name_or_id))

	return Size{}, err
}

示例#27
文件: encodedword.go 项目: reillywatson/go

func (d *WordDecoder) convert(buf *bytes.Buffer, charset string, content []byte) error {
	switch {
	case strings.EqualFold("utf-8", charset):
		buf.Write(content)
	case strings.EqualFold("iso-8859-1", charset):
		for _, c := range content {
			buf.WriteRune(rune(c))
		}
	case strings.EqualFold("us-ascii", charset):
		for _, c := range content {
			if c >= utf8.RuneSelf {
				buf.WriteRune(unicode.ReplacementChar)
			} else {
				buf.WriteByte(c)
			}
		}
	default:
		if d.CharsetReader == nil {
			return fmt.Errorf("mime: unhandled charset %q", charset)
		}
		r, err := d.CharsetReader(strings.ToLower(charset), bytes.NewReader(content))
		if err != nil {
			return err
		}
		if _, err = buf.ReadFrom(r); err != nil {
			return err
		}
	}
	return nil
}

示例#28
文件: ttf_fonts.go 项目: rowland/leadtype

func (fc *TtfFonts) Select(family, weight, style string, ranges []string) (fontMetrics font.FontMetrics, err error) {
	var ws string
	if weight != "" && style != "" {
		ws = weight + " " + style
	} else if weight == "" && style == "" {
		ws = "Regular"
	} else if style == "" {
		ws = weight
	} else if weight == "" {
		ws = style
	}
	if fc.fonts == nil {
		fc.fonts = make(map[string]*ttf.Font)
	}
search:
	for _, f := range fc.FontInfos {
		if strings.EqualFold(f.Family(), family) && strings.EqualFold(f.Style(), ws) {
			for _, r := range ranges {
				cpr, ok := ttf.CodepointRangesByName[r]
				if !ok || !f.CharRanges().IsSet(int(cpr.Bit)) {
					continue search
				}
			}
			font := fc.fonts[f.Filename]
			if font == nil {
				font, err = ttf.LoadFont(f.Filename)
				fc.fonts[f.Filename] = font
			}
			fontMetrics = font
			return
		}
	}
	err = fmt.Errorf("Font %s %s not found", family, ws)
	return
}

示例#29
文件: cuthandler.go 项目: aosen/searchserver

func (self *CutHandler) Base(w http.ResponseWriter, r *http.Request, g kernel.G, text string, mode string) {
	type Value struct {
		Text string `json:"text"`
		Pos  string `json:"pos"`
	}
	segmenter, _ := g.DIY["seg"].(search.SearchSegmenter)
	//通用处理方法
	if text == "" || (!strings.EqualFold(mode, "1") && !strings.EqualFold(mode, "0")) {
		self.JsonResponse(w, nil, 401)
	} else {
		//整理为输出格式
		s := []*Value{}
		//开始分词
		func() {
			for _, seg := range segmenter.Cut([]byte(text),
				func() bool {
					if mode == "1" {
						return true
					} else {
						return false
					}
				}()) {
				s = append(s, &Value{
					Text: seg.GetToken().GetText(),
					Pos:  seg.GetToken().GetPos(),
				})
			}
		}()
		self.JsonResponse(w, s, 200)
	}
}

示例#30
文件: update.go 项目: Alienero/tidb

func getUpdateColumns(t table.Table, assignList []expression.Assignment, isMultipleTable bool, tblAliasMap map[string]string) ([]*column.Col, []expression.Assignment, error) {
	// TODO: We should check the validate if assignList in somewhere else. Maybe in building plan.
	// TODO: We should use field.GetFieldIndex to replace this function.
	tcols := make([]*column.Col, 0, len(assignList))
	tAsgns := make([]expression.Assignment, 0, len(assignList))
	tname := t.TableName()
	for _, asgn := range assignList {
		if isMultipleTable {
			if tblAliasMap != nil {
				if alias, ok := tblAliasMap[asgn.TableName]; ok {
					if !strings.EqualFold(tname.O, alias) {
						continue
					}
				}
			} else if !strings.EqualFold(tname.O, asgn.TableName) {
				continue
			}
		}
		col := column.FindCol(t.Cols(), asgn.ColName)
		if col == nil {
			if isMultipleTable {
				continue
			}
			return nil, nil, errors.Errorf("UPDATE: unknown column %s", asgn.ColName)
		}
		tcols = append(tcols, col)
		tAsgns = append(tAsgns, asgn)
	}
	return tcols, tAsgns, nil
}

展开阅读全文