Golang strings.LastIndexByte函数代码示例

// Ensure that there are either loggers or placeholders all the way
// from the specified logger to the root of the logger hierarchy.
func (m *manager) fixupParents(l *Logger) {

	var parent *Logger
	name := l.name
	i := strings.LastIndexByte(name, '/')

	for i > 0 && parent == nil {
		name = name[:i]
		if node, ok := m.registry[name]; ok {
			if p, ok := node.(*placeholder); ok {
				// The logger will be child of this placeholder
				// if anybody asks later.
				p.append(l)
			} else { // it' s a *Logger
				if n, ok := node.(*Logger); ok {
					parent = n
				} else {
					panic("Bad logger in registry")
				}
			}
		} else {
			m.registry[name] = newPlaceholder(l)
		}
		i = strings.LastIndexByte(name, '/')
	}
	if parent == nil {
		parent = m.root
	}
	l.h.SwapParent(parent)
}

// LastIndexByte returns the index of the last instance of c in s
// or -f if c is not present in s
func LastIndexByte(s string, c byte) int {
	fmt.Println(strings.LastIndexByte("gogopher", 'o')) // 3
	fmt.Println(strings.LastIndexByte("gogopher", 111)) // 3
	fmt.Println(strings.LastIndexByte("gogopher", 112)) // 4
	fmt.Println(strings.LastIndexByte("gogopher", 113)) // -1
	return strings.LastIndexByte(s, c)
}

// Ensure that there are either loggers or placeholders all the way
// from the specified logger to the root of the logger hierarchy.
func (m *manager) fixupParents(l *Logger) {

	var parent *Logger
	name := l.name
	i := strings.LastIndexByte(name, '/')

	for i > 0 && parent == nil {
		name = name[:i]
		if node, ok := m.registry[name]; ok {
			if p, ok := node.(*placeholder); ok {
				// The logger will be child of this placeholder,
				// somewhere in the subtree.
				// if anybody asks later.
				p.append(l)
			} else { // it' s a *Logger, make it the parent
				if n, ok := node.(*Logger); ok {
					parent = n
				} else {
					// unreachable
					panic("Bad logger in registry")
				}
			}
		} else {
			m.registry[name] = newPlaceholder(l)
		}
		i = strings.LastIndexByte(name, '/')
	}
	if parent == nil {
		// If the logger inherited the root as parent from a child which previous had
		// the root as parent, this will just set it again
		parent = m.root
	}
	l.h.SwapParent(parent)
}

// GetPackage finds a package by a given name.
// If package doesn't exist in database, then downloads and saves information about new package.
func GetPackage(name string) *MCPMPackage {
	if !db.o {
		open(db.fn)
	}
	if pkg, ok := db.r[name]; ok {
		return pkg
	}
	ht, hte := get(util.DirPathJoin("http://minecraft.curseforge.com/projects", name))
	if hte != nil {
		return nil
	}
	url := ht.Request.URL
	pn := url.Path[strings.LastIndexByte(url.Path, '/')+1:]
	doc, doce := goquery.NewDocumentFromResponse(ht)
	if doce != nil {
		return nil
	}
	tit := doc.Find("h1.project-title a .overflow-tip").Text()
	oa := doc.Find(".RootGameCategory a").Eq(0)
	ida := doc.Find(".view-on-curse a").Eq(0)
	cat := oa.AttrOr("href", " ")
	id := ida.AttrOr("href", "")
	idn := id[strings.LastIndexByte(id, '/')+1:]
	nid, ner := strconv.ParseUint(idn, 10, 64)
	if ner != nil {
		return nil
	}
	pkg := &MCPMPackage{nid, pn, tit, cat[1:]}
	db.r[pn] = pkg
	db.r[idn] = pkg
	db.a = append(db.a, pkg)
	return pkg
}

// GetParentDir returns the parent directory(string) of the passed targetDirectory (string)
func GetParentDir(targetDirectory string) string {
	lastSlashIndex := strings.LastIndexByte(targetDirectory, os.PathSeparator)
	//check if the slash is at the end , if yes then re- check without the last slash, we don't want /path/to/ , we want /path/to in order to get the /path/ which is the parent directory of the /path/to
	if lastSlashIndex == len(targetDirectory)-1 {
		lastSlashIndex = strings.LastIndexByte(targetDirectory[0:lastSlashIndex], os.PathSeparator)
	}

	parentDirectory := targetDirectory[0:lastSlashIndex]
	return parentDirectory
}

func (l *SiteList) excludeSubDomain(site string) string {
	i := strings.LastIndexByte(site, '.')
	if i < 0 {
		return site
	}
	i2 := strings.LastIndexByte(site[:i], '.')
	if i2 < 0 {
		return site
	}
	return site[i2+1:]
}

// Get the name of the leftmost account group.
// The account name is assumed to be valid as indicated by Valid().
// Example: "e:food.snacks" -> "snacks", "e:food" -> "food", "e:" -> "expense"
func (name AccountName) Leaf() string {
	lastIndex := strings.LastIndexByte(string(name), '.')
	if lastIndex != -1 {
		return string(name[lastIndex+1:])
	}
	lastIndex = strings.LastIndexByte(string(name), ':')
	if lastIndex != -1 && len(name) > AccountNameTypePrefixLen {
		return string(name[lastIndex+1:])
	}
	return name.Type().String()
}

func GetPath(url string) string {
	p := strings.LastIndexByte(url, '?')
	if p > 0 {
		url = url[:p]
	}
	p = strings.LastIndexByte(url, '/')
	if p > 0 {
		return url[:p+1]
	}
	return "/"
}

func ParseVariableQName(qname string) (ns, name string) {
	i := strings.LastIndexByte(qname, ':')
	if i == -1 {
		return "", qname
	}
	return qname[:i+1], qname[i+1:]
}

// unexpected complains about the token and terminates processing.
func (p *parser) unexpected(tok token, expected ...TokenType) {
	const bufSize = 10
	start := tok.pos - bufSize
	if start < 0 {
		start = 0
	}
	// Skip any new lines just show a single line
	if i := strings.LastIndexByte(p.text[start:tok.pos], '\n'); i != -1 {
		start = start + i + 1
	}
	stop := tok.pos + bufSize
	if stop > len(p.text) {
		stop = len(p.text)
	}
	// Skip any new lines just show a single line
	if i := strings.IndexByte(p.text[tok.pos:stop], '\n'); i != -1 {
		stop = tok.pos + i
	}
	line, char := p.lex.lineNumber(tok.pos)
	expectedStrs := make([]string, len(expected))
	for i := range expected {
		expectedStrs[i] = fmt.Sprintf("%q", expected[i])
	}
	expectedStr := strings.Join(expectedStrs, ",")
	tokStr := tok.typ.String()
	if tok.typ == TokenError {
		tokStr = tok.val
	}
	p.errorf("unexpected %s line %d char %d in \"%s\". expected: %s", tokStr, line, char, p.text[start:stop], expectedStr)
}

func extractConsumerIdFromOwnerInfo(ownerZnodeData string) (consumerId string) {
	// ownerZnodeData:
	//   for java sdk: $consumerId-$threadNum  $consumerId: $group_$hostname-$timestamp-$uuidSignificantBits
	// for golang sdk: $consumerId
	//         others: $consumerId

	consumerId = ownerZnodeData // by default

	if !strings.Contains(ownerZnodeData, "_") {
		// java consumer group always has the "_"
		return
	}

	lastDash := strings.LastIndexByte(ownerZnodeData, '-')
	if lastDash == -1 || lastDash == len(ownerZnodeData)-1 {
		// java consumer group always has the '-' and not ends with '-'
		return
	}

	maybeJavaThreadNum := ownerZnodeData[lastDash+1:]
	if len(maybeJavaThreadNum) > 3 {
		// not a java consumer group because thread num never above 999
		return
	}

	for _, c := range maybeJavaThreadNum {
		if c < '0' || c > '9' {
			// not a java consumer group because threadNum is digit
			return
		}
	}

	// confirmed, it IS java api consumer group: discard the threadNum section
	return ownerZnodeData[:lastDash]
}

func init() {

	// set the current working dir
	if d, err := os.Getwd(); err != nil {
		panic(err)
	} else {
		workingDir = d
	}

	// defaultInstallDir is the default directory which the create will copy and run the package when finish downloading
	// it's just the last path part of the workingDir
	defaultInstallDir := workingDir[strings.LastIndexByte(workingDir, os.PathSeparator)+1:]

	// init the cli app
	app = cli.NewApp("iris", "Command line tool for Iris web framework", Version)
	// version command
	app.Command(cli.Command("version", "\t      prints your iris version").Action(func(cli.Flags) error { app.Printf("%s", iris.Version); return nil }))

	// create command/-/create.go
	createCmd := cli.Command("create", "create a project to a given directory").
		Flag("offline", false, "set to true to disable the packages download on each create command").
		Flag("dir", defaultInstallDir, "$GOPATH/src/$dir the directory to install the sample package").
		Flag("type", "basic", "creates a project based on the -t package. Currently, available types are 'basic' & 'static'").
		Action(create)

	// run command/-/run.go
	runAndWatchCmd := cli.Command("run", "runs and reload on source code changes, example: iris run main.go").Action(runAndWatch)

	// register the commands
	app.Command(createCmd)
	app.Command(runAndWatchCmd)

	// init the logger
	printer = logger.New(config.DefaultLogger())
}

// Get splits the specified name by the stored delimiter, and attempts to retrieve the nested value
// corresponding to the nested fields.
func (rc *RecordCache) Get(name string) (interface{}, error) {
	if val, ok := rc.db[name]; ok {
		return val, nil
	}

	var err error
	var val interface{}
	var parent interface{} = rc.top
	var parentName, childName string

	if index := strings.LastIndexByte(name, rc.delim); index >= 0 {
		parentName, childName = name[:index], name[index+1:]
		parent, err = rc.Get(parentName)
		if err != nil {
			return nil, err
		}
		rc.db[parentName] = parent
		if _, ok := parent.(*Record); !ok {
			return nil, ErrNotRecord{datum: parent}
		}
		name = childName
	}

	val, err = parent.(*Record).GetQualified(name)
	if err != nil {
		if nerr, ok := err.(ErrNoSuchField); ok {
			nerr.path = parentName
			return nil, nerr
		}
		return nil, err
	}

	rc.db[name] = val
	return val, nil
}

func Basename(s string) string {
	n := strings.LastIndexByte(s, '.')
	if n > 0 {
		return s[:n]
	}
	return s
}

func getContext(content []byte, offset int64) (int, string, int) {
	if offset >= int64(len(content)) || offset < 0 {
		return 0, fmt.Sprintf("[error: Offset %d is out of bounds 0..%d]", offset, len(content)), 0
	}

	lineN := strings.Count(string(content[:offset]), "\n") + 1

	start := strings.LastIndexByte(string(content[:offset]), '\n')
	if start == -1 {
		start = 0
	} else {
		start++
	}

	end := strings.IndexByte(string(content[start:]), '\n')
	l := ""
	if end == -1 {
		l = string(content[start:])
	} else {
		end = end + start
		l = string(content[start:end])
	}

	return lineN, l, (int(offset) - start)
}